feat(gnoland): Define NoopMsg to facilitate the creation of sponsor transaction (gasless transaction)

gno.land/pkg/sdk/vm/handler.go

@@ -33,6 +33,8 @@ func (vh vmHandler) Process(ctx sdk.Context, msg std.Msg) sdk.Result {
 		return vh.handleMsgCall(ctx, msg)
 	case MsgRun:
 		return vh.handleMsgRun(ctx, msg)
+	case MsgNoop:
+		return sdk.Result{}
 	default:
 		errMsg := fmt.Sprintf("unrecognized vm message type: %T", msg)
 		return abciResult(std.ErrUnknownRequest(errMsg))

gno.land/pkg/sdk/vm/handler_test.go

@@ -3,6 +3,8 @@ package vm
 import (
 	"testing"
 
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -48,3 +50,33 @@ func Test_parseQueryEval_panic(t *testing.T) {
 		parseQueryEvalData("gno.land/r/demo/users")
 	})
 }
+
+func TestProcessNoopMsg(t *testing.T) {
+	// setup
+	env := setupTestEnv()
+	ctx := env.ctx
+	vmHandler := NewHandler(env.vmk)
+
+	addr := crypto.AddressFromPreimage([]byte("test1"))
+	msg := NewMsgNoop(addr)
+
+	res := vmHandler.Process(ctx, msg)
+	assert.Empty(t, res)
+}
+
+func TestProcessInvalidMsg(t *testing.T) {
+	// setup
+	env := setupTestEnv()
+	ctx := env.ctx
+	vmHandler := NewHandler(env.vmk)
+
+	type InvalidMsg struct {
+		std.Msg
+	}
+
+	msg := InvalidMsg{}
+
+	res := vmHandler.Process(ctx, msg)
+	assert.NotEmpty(t, res)
+	assert.Equal(t, res.Error, std.UnknownRequestError{})
+}

gno.land/pkg/sdk/vm/msgs.go

@@ -207,3 +207,44 @@
 func (msg MsgRun) GetReceived() std.Coins {
 	return msg.Send
 }
+
+//----------------------------------------
+// MsgNoop
+
+// MsgNoop - executes nothing
+type MsgNoop struct {
+	Caller crypto.Address `json:"caller" yaml:"caller"`
+}
+
+var _ std.Msg = MsgNoop{}
+
+func NewMsgNoop(caller crypto.Address) MsgNoop {
+	return MsgNoop{
+		Caller: caller,
+	}
+}
+
+// Implements Msg.
+func (msg MsgNoop) Route() string { return RouterKey }
+
+// Implements Msg.
+func (msg MsgNoop) Type() string { return "no_op" }
+
+// Implements Msg.
+func (msg MsgNoop) ValidateBasic() error {
+	if msg.Caller.IsZero() {
+		return std.ErrInvalidAddress("missing caller address")
+	}
+
+	return nil
+}
+
+// Implements Msg.
+func (msg MsgNoop) GetSignBytes() []byte {
+	return std.MustSortJSON(amino.MustMarshalJSON(msg))
+}
+
+// Implements Msg.
+func (msg MsgNoop) GetSigners() []crypto.Address {
+	return []crypto.Address{msg.Caller}
+}

gno.land/pkg/sdk/vm/msgs_test.go

@@ -0,0 +1,120 @@
+package vm
+
+import (
+	"testing"
+
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMsgAddPackage(t *testing.T) {
+	creator := crypto.AddressFromPreimage([]byte("addr1"))
+	pkgPath := "gno.land/r/namespace/test"
+	files := []*std.MemFile{
+		{
+			Name: "test.gno",
+			Body: `package test
+		func Echo() string {return "hello world"}`,
+		},
+	}
+
+	msg := NewMsgAddPackage(creator, pkgPath, files)
+
+	// Validate Basic
+	err := msg.ValidateBasic()
+	require.NoError(t, err)
+
+	// Check if package name is set correctly
+	require.Equal(t, msg.Package.Name, "test")
+
+	// Test invalid address
+	msg.Creator = crypto.Address{}
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+
+	// Test invalid package path
+	msg.Creator = creator
+	msg.Package.Path = ""
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+}
+
+func TestMsgCall(t *testing.T) {
+	caller := crypto.AddressFromPreimage([]byte("addr1"))
+	pkgPath := "gno.land/r/namespace/mypkg"
+	funcName := "MyFunction"
+	args := []string{"arg1", "arg2"}
+
+	msg := NewMsgCall(caller, std.Coins{}, pkgPath, funcName, args)
+
+	// Validate Basic
+	err := msg.ValidateBasic()
+	require.NoError(t, err)
+
+	// Test invalid caller address
+	msg.Caller = crypto.Address{}
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+
+	// Test invalid package path
+	msg.Caller = caller
+	msg.PkgPath = ""
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+
+	// Test invalid function name
+	msg.PkgPath = pkgPath
+	msg.Func = ""
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+}
+
+func TestMsgRun(t *testing.T) {
+	caller := crypto.AddressFromPreimage([]byte("addr1"))
+	files := []*std.MemFile{
+		{
+			Name: "test.gno",
+			Body: `package main
+		func Echo() string {return "hello world"}`,
+		},
+	}
+
+	msg := NewMsgRun(caller, std.Coins{}, files)
+
+	// Validate Basic
+	err := msg.ValidateBasic()
+	require.NoError(t, err)
+
+	// Test invalid caller address
+	msg.Caller = crypto.Address{}
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+
+	// Test invalid package name
+	files = []*std.MemFile{
+		{
+			Name: "test.gno",
+			Body: `package test
+		func Echo() string {return "hello world"}`,
+		},
+	}
+	require.Panics(t, func() {
+		NewMsgRun(caller, std.Coins{}, files)
+	})
+}
+
+func TestMsgNoop(t *testing.T) {
+	caller := crypto.AddressFromPreimage([]byte("addr1"))
+
+	msg := NewMsgNoop(caller)
+
+	// Validate Basic
+	err := msg.ValidateBasic()
+	require.NoError(t, err)
+
+	// Test invalid caller address
+	msg.Caller = crypto.Address{}
+	err = msg.ValidateBasic()
+	require.Error(t, err)
+}

gno.land/pkg/sdk/vm/package.go

@@ -15,6 +15,7 @@ var Package = amino.RegisterPackage(amino.NewPackage(
 	MsgCall{}, "m_call",
 	MsgRun{}, "m_run",
 	MsgAddPackage{}, "m_addpkg", // TODO rename both to MsgAddPkg?
+	MsgNoop{}, "m_noop",
 
 	// errors
 	InvalidPkgPathError{}, "InvalidPkgPathError",

gno.land/pkg/sdk/vm/vm.proto

@@ -27,6 +27,10 @@ message m_addpkg {
 	string deposit = 3;
 }
 
+message m_noop {
+	string caller = 1;
+}
+
 message InvalidPkgPathError {
 }
 

tm2/pkg/sdk/auth/ante.go

@@ -139,11 +139,19 @@ func NewAnteHandler(ak AccountKeeper, bank BankKeeperI, sigGasConsumer Signature
 		stdSigs := tx.GetSignatures()
 
 		for i := 0; i < len(stdSigs); i++ {
+			var isNewAccount bool
 			// skip the fee payer, account is cached and fees were deducted already
 			if i != 0 {
 				signerAccs[i], res = GetSignerAcc(newCtx, ak, signerAddrs[i])
+				// only create new account when tx is a sponsor transaction
 				if !res.IsOK() {
-					return newCtx, res, true
+					if tx.IsSponsorTx() {
+						isNewAccount = true
+						signerAccs[i] = ak.NewAccountWithAddress(newCtx, signerAddrs[i])
+						signerAccs[i].SetPubKey(stdSigs[i].PubKey)
+					} else {
+						return newCtx, res, true
+					}
 				}
 			}
 
@@ -153,7 +161,7 @@ func NewAnteHandler(ak AccountKeeper, bank BankKeeperI, sigGasConsumer Signature
 				// No signatures are needed for genesis.
 			} else {
 				// Check signature
-				signBytes, err := GetSignBytes(newCtx.ChainID(), tx, sacc, isGenesis)
+				signBytes, err := GetSignBytes(newCtx.ChainID(), tx, sacc, isGenesis || isNewAccount)
 				if err != nil {
 					return newCtx, res, true
 				}

tm2/pkg/sdk/auth/ante_test.go

@@ -586,6 +586,51 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
 	require.Nil(t, acc2.GetPubKey())
 }
 
+func TestAnteHandlerSponsorTx(t *testing.T) {
+	t.Parallel()
+
+	// setup
+	env := setupTestEnv()
+	anteHandler := NewAnteHandler(env.acck, env.bank, DefaultSigVerificationGasConsumer, defaultAnteOptions())
+	ctx := env.ctx
+
+	// keys and addresses
+	priv1, _, addr1 := tu.KeyTestPubAddr()
+	priv2, _, addr2 := tu.KeyTestPubAddr()
+
+	// Only create and set up account acc1 (addr1)
+	acc1 := env.acck.NewAccountWithAddress(ctx, addr1)
+	acc1.SetCoins(tu.NewTestCoins())
+	require.NoError(t, acc1.SetAccountNumber(0))
+	env.acck.SetAccount(ctx, acc1)
+
+	var tx std.Tx
+
+	// test good tx and set public key
+	noopMsg := tu.NewNoopMsg(addr1)
+	msg := tu.NewTestMsg(addr2)
+
+	msgs := []std.Msg{noopMsg, msg}
+
+	privs, accnums, seqs := []crypto.PrivKey{priv1, priv2}, []uint64{0, 0}, []uint64{0, 0}
+	fee := tu.NewTestFee()
+	tx = tu.NewTestTx(t, ctx.ChainID(), msgs, privs, accnums, seqs, fee)
+	checkValidTx(t, anteHandler, ctx, tx, false)
+
+	acc1 = env.acck.GetAccount(ctx, addr1)
+	require.Equal(t, acc1.GetPubKey(), priv1.PubKey())
+	require.Equal(t, acc1.GetAccountNumber(), uint64(0))
+	require.Equal(t, acc1.GetSequence(), uint64(1))
+
+	// Account for addr2 (acc2) has not been created yet.
+	// According to the new logic, if the transaction is a SponsorTx, a new account
+	// will be created for addr2 and its public key will be set.
+	acc2 := env.acck.GetAccount(ctx, addr2)
+	require.Equal(t, acc2.GetPubKey(), priv2.PubKey())
+	require.Equal(t, acc2.GetAccountNumber(), uint64(2))
+	require.Equal(t, acc1.GetSequence(), uint64(1))
+}
+
 func TestProcessPubKey(t *testing.T) {
 	t.Parallel()
 

tm2/pkg/sdk/testutils/package.go

@@ -11,6 +11,7 @@ var Package = amino.RegisterPackage(amino.NewPackage(
 ).WithDependencies().WithTypes(
 	// ...
 	&TestMsg{}, "TestMsg",
+	&NoopMsg{}, "NoopMsg",
 
 	// testmsgs.go
 	MsgCounter{},

tm2/pkg/sdk/testutils/testutils.go

@@ -37,6 +37,34 @@
 	return msg.Signers
 }
 
+// NoopMsg - executes nothing
+type NoopMsg struct {
+	Caller crypto.Address
+}
+
+var _ std.Msg = &NoopMsg{}
+
+func NewNoopMsg(caller crypto.Address) *NoopMsg {
+	return &NoopMsg{
+		Caller: caller,
+	}
+}
+
+// Implements Msg
+func (msg NoopMsg) Route() string { return "TestMsg" }
+func (msg NoopMsg) Type() string  { return "no_op" }
+func (msg NoopMsg) GetSignBytes() []byte {
+	bz, err := amino.MarshalJSON(msg.Caller)
+	if err != nil {
+		panic(err)
+	}
+	return std.MustSortJSON(bz)
+}
+func (msg NoopMsg) ValidateBasic() error { return nil }
+func (msg NoopMsg) GetSigners() []crypto.Address {
+	return []crypto.Address{msg.Caller}
+}
+
 // ----------------------------------------
 // Utility Methods
 

tm2/pkg/std/tx.go

@@ -60,6 +60,34 @@
 	return nil
 }
 
+// IsSponsorTx checks if the transaction is a valid sponsor transaction
+func (tx Tx) IsSponsorTx() bool {
+	// At least two message in the transaction
+	if len(tx.Msgs) <= 1 {
+		return false
+	}
+
+	// The first message type is "no_op"
+	if tx.Msgs[0].Type() != "no_op" {
+		return false
+	}
+
+	// More than one signer
+	signers := tx.GetSigners()
+	if len(signers) <= 1 {
+		return false
+	}
+
+	// The first signer is different from all other signers
+	for i := 1; i < len(signers); i++ {
+		if signers[0] == signers[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
 // CountSubKeys counts the total number of keys for a multi-sig public key.
 func CountSubKeys(pub crypto.PubKey) int {
 	v, ok := pub.(multisig.PubKeyMultisigThreshold)