feat: lock token transfer and parameter module

contribs/gnodev/pkg/dev/node.go

@@ -116,10 +116,9 @@ func NewDevNode(ctx context.Context, cfg *NodeConfig) (*Node, error) {
 	}
 
 	// generate genesis state
-	genesis := gnoland.GnoGenesisState{
-		Balances: cfg.BalancesList,
-		Txs:      append(pkgsTxs, cfg.InitialTxs...),
-	}
+	genesis := gnoland.DefaultGenState()
+	genesis.Balances = cfg.BalancesList
+	genesis.Txs = append(pkgsTxs, cfg.InitialTxs...)
 
 	if err := devnode.rebuildNode(ctx, genesis); err != nil {
 		return nil, fmt.Errorf("unable to initialize the node: %w", err)
@@ -276,10 +275,9 @@ func (n *Node) Reset(ctx context.Context) error {
 
 	// Append initialTxs
 	txs := append(pkgsTxs, n.initialState...)
-	genesis := gnoland.GnoGenesisState{
-		Balances: n.config.BalancesList,
-		Txs:      txs,
-	}
+	genesis := gnoland.DefaultGenState()
+	genesis.Balances = n.config.BalancesList
+	genesis.Txs = txs
 
 	// Reset the node with the new genesis state.
 	err = n.rebuildNode(ctx, genesis)
@@ -402,9 +400,10 @@ func (n *Node) rebuildNodeFromState(ctx context.Context) error {
 			return fmt.Errorf("unable to load pkgs: %w", err)
 		}
 
-		return n.rebuildNode(ctx, gnoland.GnoGenesisState{
-			Balances: n.config.BalancesList, Txs: txs,
-		})
+		genesis := gnoland.DefaultGenState()
+		genesis.Balances = n.config.BalancesList
+		genesis.Txs = txs
+		return n.rebuildNode(ctx, genesis)
 	}
 
 	state, err := n.getBlockStoreState(ctx)
@@ -419,10 +418,9 @@ func (n *Node) rebuildNodeFromState(ctx context.Context) error {
 	}
 
 	// Create genesis with loaded pkgs + previous state
-	genesis := gnoland.GnoGenesisState{
-		Balances: n.config.BalancesList,
-		Txs:      append(pkgsTxs, state...),
-	}
+	genesis := gnoland.DefaultGenState()
+	genesis.Balances = n.config.BalancesList
+	genesis.Txs = append(pkgsTxs, state...)
 
 	// Reset the node with the new genesis state.
 	err = n.rebuildNode(ctx, genesis)

contribs/gnodev/pkg/dev/node_state.go

@@ -92,10 +92,9 @@ func (n *Node) MoveBy(ctx context.Context, x int) error {
 	newState := n.state[:newIndex]
 
 	// Create genesis with loaded pkgs + previous state
-	genesis := gnoland.GnoGenesisState{
-		Balances: n.config.BalancesList,
-		Txs:      append(pkgsTxs, newState...),
-	}
+	genesis := gnoland.DefaultGenState()
+	genesis.Balances = n.config.BalancesList
+	genesis.Txs = append(pkgsTxs, newState...)
 
 	// Reset the node with the new genesis state.
 	if err = n.rebuildNode(ctx, genesis); err != nil {
@@ -132,10 +131,10 @@ func (n *Node) ExportStateAsGenesis(ctx context.Context) (*bft.GenesisDoc, error
 
 	// Get current blockstore state
 	doc := *n.Node.GenesisDoc() // copy doc
-	doc.AppState = gnoland.GnoGenesisState{
-		Balances: n.config.BalancesList,
-		Txs:      state,
-	}
+	genState := doc.AppState.(gnoland.GnoGenesisState)
+	genState.Balances = n.config.BalancesList
+	genState.Txs = state
+	doc.AppState = genState
 
 	return &doc, nil
 }

examples/gno.land/r/sys/params/gno.mod

@@ -1,5 +1,4 @@
 module gno.land/r/sys/params
-
 require (
 	gno.land/p/demo/dao v0.0.0-latest
 	gno.land/r/gov/dao/bridge v0.0.0-latest

examples/gno.land/r/sys/params/unlock.gno

@@ -0,0 +1,39 @@
+package params
+
+import (
+	"std"
+
+	"gno.land/p/demo/dao"
+	"gno.land/r/gov/dao/bridge"
+)
+
+const lockSendKey = "lockSend.bool"
+const UnlockSendDesc = "Proposal to unlock the sending functionality for ugnot."
+const LockSendDesc = "Proposal to lock the sending functionality for ugnot."
+
+func ProposeUnlockSend() uint64 {
+	callback := func() error {
+		std.SetParamBool(lockSendKey, false)
+		return nil
+	}
+	return propose(callback, UnlockSendDesc)
+}
+
+func ProposeLockSend() uint64 {
+	callback := func() error {
+		std.SetParamBool(lockSendKey, true)
+		return nil
+	}
+	return propose(callback, LockSendDesc)
+}
+
+func propose(callback func() error, desc string) uint64 {
+	// The callback function is executed only after the proposal is voted on
+	// and approved by the GovDAO.
+	exe := bridge.GovDAO().NewGovDAOExecutor(callback)
+	prop := dao.ProposalRequest{
+		Description: desc,
+		Executor:    exe,
+	}
+	return bridge.GovDAO().Propose(prop)
+}

examples/gno.land/r/sys/params/unlock_test.gno

@@ -0,0 +1,49 @@
+package params
+
+import (
+	"testing"
+
+	"gno.land/p/demo/dao"
+	"gno.land/p/demo/simpledao"
+	"gno.land/p/demo/urequire"
+	"gno.land/r/gov/dao/bridge"
+)
+
+func TestProUnlockSend(t *testing.T) {
+	govdao := bridge.GovDAO()
+	id := ProposeUnlockSend()
+	p, err := govdao.GetPropStore().ProposalByID(id)
+	urequire.NoError(t, err)
+	urequire.Equal(t, UnlockSendDesc, p.Description())
+}
+
+func TestFailUnlockSend(t *testing.T) {
+	govdao := bridge.GovDAO()
+	id := ProposeUnlockSend()
+	urequire.PanicsWithMessage(
+		t,
+		simpledao.ErrProposalNotAccepted.Error(),
+		func() {
+			govdao.ExecuteProposal(id)
+		},
+	)
+}
+
+func TestExeUnlockSend(t *testing.T) {
+	govdao := bridge.GovDAO()
+	id := ProposeUnlockSend()
+	p, err := govdao.GetPropStore().ProposalByID(id)
+	urequire.NoError(t, err)
+	urequire.True(t, dao.Active == p.Status())
+
+	govdao.VoteOnProposal(id, dao.YesVote)
+	urequire.True(t, dao.Accepted == p.Status())
+	urequire.NotPanics(
+		t,
+		func() {
+			govdao.ExecuteProposal(id)
+		},
+	)
+
+	urequire.True(t, dao.ExecutionSuccessful == p.Status())
+}

gno.land/cmd/gnoland/start.go

@@ -410,10 +410,10 @@ func generateGenesisFile(genesisFile string, pk crypto.PubKey, c *startCfg) erro
 	genesisTxs = append(pkgsTxs, genesisTxs...)
 
 	// Construct genesis AppState.
-	gen.AppState = gnoland.GnoGenesisState{
-		Balances: balances,
-		Txs:      genesisTxs,
-	}
+	defaultGenState := gnoland.DefaultGenState()
+	defaultGenState.Balances = balances
+	defaultGenState.Txs = genesisTxs
+	gen.AppState = defaultGenState
 
 	// Write genesis state
 	if err := gen.SaveAs(genesisFile); err != nil {

gno.land/cmd/gnoland/testdata/transfer_lock.txtar

@@ -0,0 +1,54 @@
+## It tests locking token transfers while allowing the payment of gas fees.
+
+## locking transfer applies to regular acocunts 
+adduser regular1
+
+
+loadpkg gno.land/r/demo/wugnot
+loadpkg gno.land/r/demo/echo
+
+## start a new node.
+## The -lock-transfer flag is intended for integration testing purposes
+## and is not a valid application flag for gnoland.
+
+gnoland start -lock-transfer
+
+## User test1 is an unrestricted account specified in the genesis state
+gnokey maketx send -send "9999999ugnot" -to $USER_ADDR_regular1 -gas-fee 1ugnot -gas-wanted 10000000 -broadcast -chainid=tendermint_test test1
+
+stdout 'OK!'
+
+## Restricted simple token transfer
+! gnokey maketx send -send "9999999ugnot" -to g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5 -gas-fee 1ugnot -gas-wanted 10000000 -broadcast -chainid=tendermint_test regular1
+stderr 'restricted token transfer error'
+
+## Restricted token transfer by calling a realm deposit function.
+! gnokey maketx call -pkgpath gno.land/r/demo/wugnot -func Deposit -gas-fee 1000000ugnot -send "10000ugnot" -gas-wanted 2000000 -broadcast -chainid=tendermint_test regular1
+stderr 'restricted token transfer error'
+
+
+## Restricted token transfer with depositing to a realm package while adding a package.
+! gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/bank -deposit "1000ugnot" -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test regular1
+stderr 'restricted token transfer error'
+
+## paying gas fees to add a package is acceptable.
+gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/bank -gas-fee 1000000ugnot -gas-wanted 2500000 -broadcast -chainid=tendermint_test regular1
+stdout 'OK!'
+
+## paying gas fees to call a realm function is acceptable.
+gnokey maketx call -pkgpath gno.land/r/demo/echo -func Render -args "Hello!" -gas-fee 1000000ugnot -gas-wanted 2500000 -broadcast -chainid=tendermint_test regular1
+stdout 'Hello!'
+
+-- bank.gno --
+package bank
+import (
+"std"
+)
+func Withdraw(denom string, amt int64) string{
+  caller := std.GetOrigCaller()
+  coin := std.Coins{{denom, amt}}
+  banker := std.GetBanker(std.BankerTypeOrigSend)
+  pkgaddr := std.GetOrigPkgAddr()
+  banker.SendCoins(pkgaddr, caller, coin)
+  return "Withdrawed!"
+}

gno.land/cmd/gnoland/testdata/transfer_unlock.txtar

@@ -0,0 +1,42 @@
+## It tests unlocking token transfers through GovDAO voting
+loadpkg gno.land/r/sys/params
+loadpkg gno.land/r/gov/dao/v2
+
+patchpkg "g1wymu47drhr0kuq2098m792lytgtj2nyx77yrsm" "g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5"
+
+adduser regular1
+
+## start a new node
+gnoland start -lock-transfer
+
+## User test1 is an unrestricted account specified in the genesis state
+gnokey maketx send -send "9999999ugnot" -to $USER_ADDR_regular1 -gas-fee 1ugnot -gas-wanted 10000000 -broadcast -chainid=tendermint_test test1
+
+stdout 'OK!'
+
+## Restricted simple token transfer for a regular account
+! gnokey maketx send -send "100ugnot" -to g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5 -gas-fee 1ugnot -gas-wanted 10000000 -broadcast -chainid=tendermint_test regular1
+
+stderr 'restricted token transfer error'
+
+## Submit a proposal to unlock the transfer. When token transfer is locked, only the predefined unrestricted account test1 in the genesis state can
+## pay the fee and submit a proposal to unlock the transfer.
+gnokey maketx call -pkgpath gno.land/r/sys/params -func ProposeUnlockSend -send 250000000ugnot -gas-fee 1ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+
+stdout '(0 uint64)'
+
+
+## vote unlock proposal with unrestricted account test1
+gnokey maketx call -pkgpath gno.land/r/gov/dao/v2 -func VoteOnProposal -args 0 -args "YES"  -send 250000000ugnot -gas-fee 1ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+
+stdout 'OK!'
+
+## vote unlock proposal with unrestricted account test1
+gnokey maketx call -pkgpath gno.land/r/gov/dao/v2 -func ExecuteProposal -args 0 -send 250000000ugnot -gas-fee 1ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+
+stdout 'OK!'
+
+## Restricted transfer is unlocked, allowing simple token transfers for regular accounts.
+gnokey maketx send -send "100ugnot" -to g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5 -gas-fee 1ugnot -gas-wanted 10000000 -broadcast -chainid=tendermint_test regular1
+
+stdout 'OK!'