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

@@ -1,14 +1,14 @@
 package gnoclient
 
 import (
+	"github.com/jaekwon/testify/assert"
 	"testing"
 
 	"github.com/gnolang/gno/gno.land/pkg/integration"
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	rpcclient "github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
 	"github.com/gnolang/gno/tm2/pkg/log"
-	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/jaekwon/testify/require"
 )
 
@@ -32,7 +32,7 @@ func newInMemorySigner(t *testing.T, chainid string) *SignerFromKeybase {
 
 func TestClient_Request(t *testing.T) {
 	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
-	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNoopLogger(), config)
+	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNopLogger(), config)
 	defer node.Stop()
 
 	signer := newInMemorySigner(t, config.TMConfig.ChainID())
@@ -52,49 +52,229 @@ func TestClient_Request(t *testing.T) {
 	// XXX: need more test
 }
 
-func TestClient_Run(t *testing.T) {
+func TestClient_Call(t *testing.T) {
+	t.Parallel()
+
 	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
-	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNoopLogger(), config)
+	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.NewHTTP(remoteAddr, "/websocket"),
+		RPCClient: rpcClient,
 	}
 
-	code := `package main
+	cfg := BaseTxCfg{
+		GasWanted:      100000,
+		GasFee:         "10000ugnot",
+		AccountNumber:  1,
+		SequenceNumber: 1,
+		Memo:           "Test memo",
+	}
 
-import (
-	"std"
+	msg := []MsgCall{
+		{
+			PkgPath:  "gno.land/r/demo/deep/very/deep",
+			FuncName: "Render",
+			Args:     []string{""},
+			Send:     "100ugnot",
+		},
+	}
 
-	"gno.land/p/demo/ufmt"
-	"gno.land/r/demo/tests"
-)
+	res, err := client.Call(cfg, msg...)
+	assert.NoError(t, err)
+	assert.NotNil(t, res)
+}
 
-func main() {
-	println(ufmt.Sprintf("- before: %d", tests.Counter()))
-	for i := 0; i < 10; i++ {
-		tests.IncCounter()
-	}
-	println(ufmt.Sprintf("- after: %d", tests.Counter()))
-}`
-	memPkg := &std.MemPackage{
-		Files: []*std.MemFile{
-			{
-				Name: "main.gno",
-				Body: code,
+func TestClient_Call_Errors(t *testing.T) {
+	t.Parallel()
+
+	// todo Replace with mock client
+	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           BaseTxCfg
+		msgs          []MsgCall
+		expectedError error
+	}{
+		{
+			name: "Invalid Signer",
+			client: Client{
+				nil,
+				rpcClient,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "RandomName",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrMissingSigner,
+		},
+		{
+			name: "Invalid RPCClient",
+			client: Client{
+				signer,
+				nil,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "RandomName",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrMissingRPCClient,
+		},
+		{
+			name: "Invalid Gas Fee",
+			client: Client{
+				signer,
+				rpcClient,
 			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "RandomName",
+				},
+			},
+			expectedError: ErrInvalidGasFee,
+		},
+		{
+			name: "Negative Gas Wanted",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      -1,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "RandomName",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrInvalidGasWanted,
+		},
+		{
+			name: "0 Gas Wanted",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      0,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "RandomName",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrInvalidGasWanted,
+		},
+		{
+			name: "Invalid PkgPath",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "",
+					FuncName: "RandomName",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrEmptyPkgPath,
+		},
+		{
+			name: "Invalid FuncName",
+			client: Client{
+				signer,
+				rpcClient,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgCall{
+				{
+					PkgPath:  "random/path",
+					FuncName: "",
+					Send:     "",
+					Args:     []string{},
+				},
+			},
+			expectedError: ErrEmptyFuncName,
 		},
 	}
-	res, err := client.Run(RunCfg{
-		Package:   memPkg,
-		GasFee:    "1ugnot",
-		GasWanted: 100000000,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, res)
-	require.NotEmpty(t, res.DeliverTx.Data)
-	require.Equal(t, string(res.DeliverTx.Data), "- before: 0\n- after: 10\n")
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			res, err := tc.client.Call(tc.cfg, tc.msgs...)
+			assert.Equal(t, err, tc.expectedError)
+			assert.Nil(t, res)
+		})
+	}
 }