feat(gnoclient): add MultiCall

gno.land/pkg/gnoclient/client.go

@@ -2,7 +2,6 @@ package gnoclient
 
 import (
 	rpcclient "github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
-	"github.com/gnolang/gno/tm2/pkg/errors"
 )
 
 // Client provides an interface for interacting with the blockchain.
@@ -14,15 +13,15 @@ type Client struct {
 // validateSigner checks that the signer is correctly configured.
 func (c Client) validateSigner() error {
 	if c.Signer == nil {
-		return errors.New("missing Signer")
+		return errMissingSigner
 	}
 	return nil
 }
 
 // validateRPCClient checks that the RPCClient is correctly configured.
 func (c Client) validateRPCClient() error {
 	if c.RPCClient == nil {
-		return errors.New("missing RPCClient")
+		return errMissingRPCClient
 	}
 	return nil
 }

gno.land/pkg/gnoclient/client_test.go

@@ -50,3 +50,107 @@
 
 	// XXX: need more test
 }
+
+func TestClient_Call(t *testing.T) {
+	t.Parallel()
+
+	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
+	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNopLogger(), config)
+	defer node.Stop()
+
+	signer := newInMemorySigner(t, config.TMConfig.ChainID())
+	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
+
+	client := Client{
+		Signer:    signer,
+		RPCClient: rpcClient,
+	}
+
+	cfg := CallCfg{
+		Msgs: []MsgCall{
+			{
+				PkgPath:  "gno.land/r/demo/deep/very/deep",
+				FuncName: "Render",
+				Args:     []string{""},
+				Send:     "",
+			},
+		},
+		GasFee:         "1000000ugnot",
+		GasWanted:      8000000,
+		AccountNumber:  0,
+		SequenceNumber: 0,
+	}
+
+	_, err := client.Call(cfg)
+	require.NoError(t, err)
+}
+
+func TestClient_Call_Errors(t *testing.T) {
+	t.Parallel()
+
+	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
+	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNopLogger(), config)
+	defer node.Stop()
+
+	signer := newInMemorySigner(t, config.TMConfig.ChainID())
+	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
+
+	testCases := []struct {
+		name          string
+		client        Client
+		cfg           CallCfg
+		expectedError error
+	}{
+		{
+			name: "Invalid Signer",
+			client: Client{
+				nil,
+				rpcClient,
+			},
+			cfg:           CallCfg{},
+			expectedError: errMissingSigner,
+		},
+		{
+			name: "Invalid RPCClient",
+			client: Client{
+				signer,
+				nil,
+			},
+			cfg:           CallCfg{},
+			expectedError: errMissingRPCClient,
+		},
+		{
+			name: "Invalid PkgPath",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: CallCfg{
+				Msgs: []MsgCall{
+					{PkgPath: ""},
+				},
+			},
+			expectedError: errInvalidPkgPath,
+		},
+		{
+			name: "Invalid FuncName",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: CallCfg{
+				Msgs: []MsgCall{
+					{PkgPath: "random/path", FuncName: ""},
+				},
+			},
+			expectedError: errInvalidFuncName,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := tc.client.Call(tc.cfg)
+			require.Equal(t, err, tc.expectedError)
+		})
+	}
+}

gno.land/pkg/gnoclient/client_txs.go

@@ -8,77 +8,86 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/std"
 )
 
+// MsgCall - syntax sugar for vm.MsgCall
+type MsgCall struct {
+	PkgPath  string   // Package path
+	FuncName string   // Function name
+	Args     []string // Function arguments
+	Send     string   // Send amount
+}
+
 // CallCfg contains configuration options for executing a contract call.
 type CallCfg struct {
-	PkgPath        string   // Package path
-	FuncName       string   // Function name
-	Args           []string // Function arguments
-	GasFee         string   // Gas fee
-	GasWanted      int64    // Gas wanted
-	Send           string   // Send amount
-	AccountNumber  uint64   // Account number
-	SequenceNumber uint64   // Sequence number
-	Memo           string   // Memo
+	Msgs           []MsgCall
+	GasFee         string // Gas fee
+	GasWanted      int64  // Gas wanted
+	AccountNumber  uint64 // Account number
+	SequenceNumber uint64 // Sequence number
+	Memo           string // Memo
 }
 
 // Call executes a contract call on the blockchain.
 func (c *Client) Call(cfg CallCfg) (*ctypes.ResultBroadcastTxCommit, error) {
 	// Validate required client fields.
 	if err := c.validateSigner(); err != nil {
-		return nil, errors.Wrap(err, "validate signer")
+		return nil, err
 	}
 	if err := c.validateRPCClient(); err != nil {
-		return nil, errors.Wrap(err, "validate RPC client")
+		return nil, err
 	}
 
-	pkgPath := cfg.PkgPath
-	funcName := cfg.FuncName
-	args := cfg.Args
-	gasWanted := cfg.GasWanted
-	gasFee := cfg.GasFee
-	send := cfg.Send
-	sequenceNumber := cfg.SequenceNumber
-	accountNumber := cfg.AccountNumber
-	memo := cfg.Memo
-
-	// Validate config.
-	if pkgPath == "" {
-		return nil, errors.New("missing PkgPath")
-	}
-	if funcName == "" {
-		return nil, errors.New("missing FuncName")
+	msgs := make([]vm.MsgCall, 0, len(cfg.Msgs))
+	for _, msg := range cfg.Msgs {
+		// Validate config.
+		if msg.PkgPath == "" {
+			return nil, errInvalidPkgPath
+		}
+		if msg.FuncName == "" {
+			return nil, errInvalidFuncName
+		}
+
+		// Parse send amount.
+		sendCoins, err := std.ParseCoins(msg.Send)
+		if err != nil {
+			return nil, errors.Wrap(err, "parsing send coins")
+		}
+
+		if err != nil {
+			return nil, errors.Wrap(err, "parsing gas fee coin")
+		}
+
+		caller := c.Signer.Info().GetAddress()
+
+		msgs = append(msgs, vm.MsgCall{
+			Caller:  caller,
+			Send:    sendCoins,
+			PkgPath: msg.PkgPath,
+			Func:    msg.FuncName,
+			Args:    msg.Args,
+		})
 	}
 
-	// Parse send amount.
-	sendCoins, err := std.ParseCoins(send)
-	if err != nil {
-		return nil, errors.Wrap(err, "parsing send coins")
+	// Cast vm.MsgCall back into std.Msg
+	stdMsgs := make([]std.Msg, len(msgs))
+	for i, msg := range msgs {
+		stdMsgs[i] = msg
 	}
 
 	// Parse gas wanted & fee.
-	gasFeeCoins, err := std.ParseCoin(gasFee)
+	gasFeeCoins, err := std.ParseCoin(cfg.GasFee)
 	if err != nil {
 		return nil, errors.Wrap(err, "parsing gas fee coin")
 	}
 
-	caller := c.Signer.Info().GetAddress()
-
-	// Construct message & transaction and marshal.
-	msg := vm.MsgCall{
-		Caller:  caller,
-		Send:    sendCoins,
-		PkgPath: pkgPath,
-		Func:    funcName,
-		Args:    args,
-	}
+	// Pack transaction
 	tx := std.Tx{
-		Msgs:       []std.Msg{msg},
-		Fee:        std.NewFee(gasWanted, gasFeeCoins),
+		Msgs:       stdMsgs,
+		Fee:        std.NewFee(cfg.GasWanted, gasFeeCoins),
 		Signatures: nil,
-		Memo:       memo,
+		Memo:       "",
 	}
 
-	return c.signAndBroadcastTxCommit(tx, accountNumber, sequenceNumber)
+	return c.signAndBroadcastTxCommit(tx, cfg.AccountNumber, cfg.SequenceNumber)
 }
 
 // signAndBroadcastTxCommit signs a transaction and broadcasts it, returning the result.

gno.land/pkg/gnoclient/errors.go

@@ -0,0 +1,10 @@
+package gnoclient
+
+import "errors"
+
+var (
+	errInvalidPkgPath   = errors.New("invalid pkgpath")
+	errInvalidFuncName  = errors.New("invalid function name")
+	errMissingSigner    = errors.New("missing Signer")
+	errMissingRPCClient = errors.New("missing RPCClient")
+)