chore(gnoclient): modify Run to use baseTxCfg & multiple MsgRun args

gno.land/pkg/gnoclient/client_test.go

@@ -54,6 +54,7 @@ func TestClient_Render(t *testing.T) {
 	assert.Equal(t, data.Response.Data, expectedRender)
 }
 
+// Call tests
 func TestClient_CallSingle(t *testing.T) {
 	t.Parallel()
 
@@ -359,3 +360,188 @@ func TestClient_Call_Errors(t *testing.T) {
 		})
 	}
 }
+
+// Run tests
+func TestClient_Run_Errors(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name          string
+		client        Client
+		cfg           BaseTxCfg
+		msgs          []MsgRun
+		expectedError error
+	}{
+		{
+			name: "Invalid Signer",
+			client: Client{
+				Signer:    nil,
+				RPCClient: &mockRPCClient{},
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgRun{
+				{
+					Package: &std.MemPackage{
+						Name: "",
+						Path: "",
+						Files: []*std.MemFile{
+							{
+								Name: "file1.gno",
+								Body: "",
+							},
+						},
+					},
+					Send: "",
+				},
+			},
+			expectedError: ErrMissingSigner,
+		},
+		{
+			name: "Invalid RPCClient",
+			client: Client{
+				&mockSigner{},
+				nil,
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs:          []MsgRun{},
+			expectedError: ErrMissingRPCClient,
+		},
+		{
+			name: "Invalid Gas Fee",
+			client: Client{
+				Signer:    &mockSigner{},
+				RPCClient: &mockRPCClient{},
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgRun{
+				{
+					Package: &std.MemPackage{
+						Name: "",
+						Path: "",
+						Files: []*std.MemFile{
+							{
+								Name: "file1.gno",
+								Body: "",
+							},
+						},
+					},
+					Send: "",
+				},
+			},
+			expectedError: ErrInvalidGasFee,
+		},
+		{
+			name: "Negative Gas Wanted",
+			client: Client{
+				Signer:    &mockSigner{},
+				RPCClient: &mockRPCClient{},
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      -1,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgRun{
+				{
+					Package: &std.MemPackage{
+						Name: "",
+						Path: "",
+						Files: []*std.MemFile{
+							{
+								Name: "file1.gno",
+								Body: "",
+							},
+						},
+					},
+					Send: "",
+				},
+			},
+			expectedError: ErrInvalidGasWanted,
+		},
+		{
+			name: "0 Gas Wanted",
+			client: Client{
+				Signer:    &mockSigner{},
+				RPCClient: &mockRPCClient{},
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      0,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgRun{
+				{
+					Package: &std.MemPackage{
+						Name: "",
+						Path: "",
+						Files: []*std.MemFile{
+							{
+								Name: "file1.gno",
+								Body: "",
+							},
+						},
+					},
+					Send: "",
+				},
+			},
+			expectedError: ErrInvalidGasWanted,
+		},
+		{
+			name: "Invalid Empty Package",
+			client: Client{
+				Signer:    &mockSigner{},
+				RPCClient: &mockRPCClient{},
+			},
+			cfg: BaseTxCfg{
+				GasWanted:      100000,
+				GasFee:         "10000ugnot",
+				AccountNumber:  1,
+				SequenceNumber: 1,
+				Memo:           "Test memo",
+			},
+			msgs: []MsgRun{
+				{
+					Package: &std.MemPackage{
+						Name:  "",
+						Path:  "",
+						Files: []*std.MemFile{},
+					},
+					Send: "",
+				},
+			},
+			expectedError: ErrEmptyPackage,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			res, err := tc.client.Run(tc.cfg, tc.msgs...)
+			assert.Nil(t, res)
+			assert.ErrorIs(t, err, tc.expectedError)
+		})
+	}
+}

gno.land/pkg/gnoclient/client_txs.go

@@ -12,6 +12,7 @@
 var (
 	ErrEmptyPkgPath     = errors.New("empty pkg path")
 	ErrEmptyFuncName    = errors.New("empty function name")
+	ErrEmptyPackage     = errors.New("empty package to run")
 	ErrInvalidGasWanted = errors.New("invalid gas wanted")
 	ErrInvalidGasFee    = errors.New("invalid gas fee")
 	ErrMissingSigner    = errors.New("missing Signer")
@@ -34,14 +35,9 @@
 	Send     string   // Send amount
 }
 
-// RunCfg contains configuration options for running a temporary package on the blockchain.
-type RunCfg struct {
-	Package        *std.MemPackage
-	GasFee         string // Gas fee
-	GasWanted      int64  // Gas wanted
-	AccountNumber  uint64 // Account number
-	SequenceNumber uint64 // Sequence number
-	Memo           string // Memo
+type MsgRun struct {
+	Package *std.MemPackage // Package to run
+	Send    string          // Send amount
 }
 
 // Call executes a contract call on the blockchain.
@@ -106,59 +102,73 @@
 	return c.signAndBroadcastTxCommit(tx, cfg.AccountNumber, cfg.SequenceNumber)
 }
 
-// Temporarily load cfg.Package on the blockchain and run main() which can
-// call realm functions and use println() to output to the "console".
-// This returns bres where string(bres.DeliverTx.Data) is the "console" output.
-func (c *Client) Run(cfg RunCfg) (*ctypes.ResultBroadcastTxCommit, error) {
-	// Validate required client fields.
+func (c *Client) Run(cfg BaseTxCfg, msgs ...MsgRun) (*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
 	}
 
-	memPkg := cfg.Package
-	gasWanted := cfg.GasWanted
-	gasFee := cfg.GasFee
-	sequenceNumber := cfg.SequenceNumber
-	accountNumber := cfg.AccountNumber
-	memo := cfg.Memo
-
-	// Validate config.
-	if memPkg.IsEmpty() {
-		return nil, errors.New("found an empty package " + memPkg.Path)
+	// Validate base transaction config
+	if err := cfg.validateBaseTxConfig(); err != nil {
+		return nil, err
 	}
 
-	// Parse gas wanted & fee.
-	gasFeeCoins, err := std.ParseCoin(gasFee)
-	if err != nil {
-		return nil, errors.Wrap(err, "parsing gas fee coin")
+	// Parse MsgRun slice
+	vmMsgs := make([]vm.MsgRun, 0, len(msgs))
+	for _, msg := range msgs {
+		// Validate MsgCall fields
+		if err := msg.validateMsgRun(); err != nil {
+			return nil, err
+		}
+
+		// Parse send coins
+		send, err := std.ParseCoins(msg.Send)
+		if err != nil {
+			return nil, err
+		}
+
+		caller := c.Signer.Info().GetAddress()
+
+		// Precompile and validate Gno syntax
+		if err = gno.PrecompileAndCheckMempkg(msg.Package); err != nil {
+			return nil, err
+		}
+
+		msg.Package.Name = "main"
+		msg.Package.Path = "gno.land/r/" + caller.String() + "/run"
+
+		// Unwrap syntax sugar to vm.MsgCall slice
+		vmMsgs = append(vmMsgs, vm.MsgRun{
+			Caller:  caller,
+			Package: msg.Package,
+			Send:    send,
+		})
 	}
 
-	caller := c.Signer.Info().GetAddress()
+	// Cast vm.MsgRun back into std.Msg
+	stdMsgs := make([]std.Msg, len(vmMsgs))
+	for i, msg := range vmMsgs {
+		stdMsgs[i] = msg
+	}
 
-	// precompile and validate syntax
-	err = gno.PrecompileAndCheckMempkg(memPkg)
+	// Parse gas fee
+	gasFeeCoins, err := std.ParseCoin(cfg.GasFee)
 	if err != nil {
-		return nil, errors.Wrap(err, "precompile and check")
+		return nil, err
 	}
-	memPkg.Name = "main"
-	memPkg.Path = "gno.land/r/" + caller.String() + "/run"
 
-	// Construct message & transaction and marshal.
-	msg := vm.MsgRun{
-		Caller:  caller,
-		Package: memPkg,
-	}
+	// 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:       cfg.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/util.go

@@ -1,10 +1,10 @@
 package gnoclient
 
 func (cfg BaseTxCfg) validateBaseTxConfig() error {
-	if cfg.GasWanted < 0 {
+	if cfg.GasWanted <= 0 {
 		return ErrInvalidGasWanted
 	}
-	if cfg.GasFee < "" {
+	if cfg.GasFee == "" {
 		return ErrInvalidGasFee
 	}
 
@@ -20,3 +20,10 @@
 	}
 	return nil
 }
+
+func (msg MsgRun) validateMsgRun() error {
+	if msg.Package == nil || len(msg.Package.Files) == 0 {
+		return ErrEmptyPackage
+	}
+	return nil
+}