feat: sync evm nonce with cosmos

app/ante/ante.go

@@ -94,7 +94,7 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 		ante.NewValidateSigCountDecorator(options.AccountKeeper),
 		ante.NewSigGasConsumeDecorator(options.AccountKeeper, sigGasConsumer),
 		NewSigVerificationDecorator(options.AccountKeeper, options.EVMKeeper, options.SignModeHandler),
-		ante.NewIncrementSequenceDecorator(options.AccountKeeper),
+		NewIncrementSequenceDecorator(options.AccountKeeper),
 		ibcante.NewRedundantRelayDecorator(options.IBCkeeper),
 		auctionante.NewAuctionDecorator(options.AuctionKeeper, options.TxEncoder, options.MevLane),
 	}

app/ante/sigverify.go

@@ -23,6 +23,7 @@
 
 	"github.com/initia-labs/initia/crypto/ethsecp256k1"
 	evmkeeper "github.com/initia-labs/minievm/x/evm/keeper"
+	evmtypes "github.com/initia-labs/minievm/x/evm/types"
 )
 
 // SigVerificationDecorator verifies all signatures for a tx and return an error if any are invalid. Note,
@@ -198,3 +199,85 @@
 
 	return nil
 }
+
+// IncrementSequenceDecorator handles incrementing sequences of all signers.
+// Use the IncrementSequenceDecorator decorator to prevent replay attacks. Note,
+// there is need to execute IncrementSequenceDecorator on RecheckTx since
+// BaseApp.Commit() will set the check state based on the latest header.
+//
+// NOTE: Since CheckTx and DeliverTx state are managed separately, subsequent and
+// sequential txs orginating from the same account cannot be handled correctly in
+// a reliable way unless sequence numbers are managed and tracked manually by a
+// client. It is recommended to instead use multiple messages in a tx.
+//
+// NOTE: When we execute evm messages, it whould handle sequence number increment internally,
+// so we need to decrease sequence number if it is used in EVM.
+type IncrementSequenceDecorator struct {
+	ak authante.AccountKeeper
+}
+
+func NewIncrementSequenceDecorator(ak authante.AccountKeeper) IncrementSequenceDecorator {
+	return IncrementSequenceDecorator{
+		ak: ak,
+	}
+}
+
+func (isd IncrementSequenceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
+	sigTx, ok := tx.(authsigning.SigVerifiableTx)
+	if !ok {
+		return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type")
+	}
+
+	// increment sequence of all signers
+	signers, err := sigTx.GetSigners()
+	if err != nil {
+		return sdk.Context{}, err
+	}
+
+	for _, signer := range signers {
+		acc := isd.ak.GetAccount(ctx, signer)
+		if err := acc.SetSequence(acc.GetSequence() + 1); err != nil {
+			panic(err)
+		}
+
+		isd.ak.SetAccount(ctx, acc)
+	}
+
+	// decrement sequence of all signers which is used in EVM
+	// when we execute evm messages, it whould handle sequence number increment.
+	if simulate || ctx.ExecMode() == sdk.ExecModeFinalize {
+		signerMap := make(map[string]bool)
+		for _, msg := range tx.GetMsgs() {
+			var caller string
+			switch msg := msg.(type) {
+			case *evmtypes.MsgCreate:
+				caller = msg.Sender
+			case *evmtypes.MsgCreate2:
+				caller = msg.Sender
+			case *evmtypes.MsgCall:
+				caller = msg.Sender
+			default:
+				continue
+			}
+
+			if _, ok := signerMap[caller]; ok {
+				continue
+			}
+			signerMap[caller] = true
+
+			callerAccAddr, err := isd.ak.AddressCodec().StringToBytes(caller)
+			if err != nil {
+				return ctx, err
+			}
+
+			acc := isd.ak.GetAccount(ctx, callerAccAddr)
+			if err := acc.SetSequence(acc.GetSequence() - 1); err != nil {
+				panic(err)
+			}
+
+			isd.ak.SetAccount(ctx, acc)
+		}
+	}
+
+	return next(ctx, tx, simulate)
+}

jsonrpc/backend/tx.go

@@ -9,6 +9,7 @@
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core"
 	coretypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 
@@ -78,6 +79,10 @@
 		accSeq = acc.GetSequence()
 	}
 
+	if accSeq > txSeq {
+		return fmt.Errorf("%w: next nonce %v, tx nonce %v", core.ErrNonceTooLow, accSeq, txSeq)
+	}
+
 	b.logger.Debug("enqueue tx", "sender", senderHex, "txSeq", txSeq, "accSeq", accSeq)
 	cacheKey := fmt.Sprintf("%s-%d", senderHex, txSeq)
 	_ = b.queuedTxs.Add(cacheKey, txBytes)
@@ -161,8 +166,12 @@
 	if blockNumber == rpc.PendingBlockNumber {
 		queryCtx = b.app.GetContextForCheckTx(nil)
 	} else {
+		if blockNumber < 0 {
+			blockNumber = 0
+		}
+
 		var err error
-		queryCtx, err = b.app.CreateQueryContext(0, false)
+		queryCtx, err = b.app.CreateQueryContext(blockNumber.Int64(), false)
 		if err != nil {
 			return nil, err
 		}

proto/minievm/evm/v1/auth.proto

@@ -2,17 +2,18 @@ syntax = "proto3";
 package minievm.evm.v1;
 
 import "amino/amino.proto";
-import "gogoproto/gogo.proto";
 import "cosmos/auth/v1beta1/auth.proto";
+import "gogoproto/gogo.proto";
 
 option go_package = "github.com/initia-labs/minievm/x/evm/types";
 
 // ContractAccount defines an account of contract.
 message ContractAccount {
-  option (amino.name)                = "evm/ContractAccount";
+  option (amino.name) = "evm/ContractAccount";
   option (gogoproto.goproto_getters) = false;
 
   cosmos.auth.v1beta1.BaseAccount base_account = 1 [(gogoproto.embed) = true];
+  bytes code_hash = 2;
 }
 
 // ShorthandAccount defines an account of shorthand address
@@ -21,9 +22,9 @@ message ContractAccount {
 // Also it is used to check the existence of the account before
 // creating a new account.
 message ShorthandAccount {
-  option (amino.name)                = "evm/ShorthandAccount";
+  option (amino.name) = "evm/ShorthandAccount";
   option (gogoproto.goproto_getters) = false;
 
-  cosmos.auth.v1beta1.BaseAccount base_account     = 1 [(gogoproto.embed) = true];
-  string                          original_address = 2;
-}
+  cosmos.auth.v1beta1.BaseAccount base_account = 1 [(gogoproto.embed) = true];
+  string original_address = 2;
+}

x/evm/keeper/context.go

@@ -226,16 +226,11 @@ func (k Keeper) EVMStaticCallWithTracer(ctx context.Context, caller common.Addre
 
 // EVMCall executes an EVM call with the given input data.
 func (k Keeper) EVMCall(ctx context.Context, caller common.Address, contractAddr common.Address, inputBz []byte, value *uint256.Int) ([]byte, types.Logs, error) {
-	return k.EVMCallWithTracer(ctx, caller, contractAddr, inputBz, value, false, nil)
-}
-
-// EVMCallWithNonceIncrement executes an EVM call with the given input data and increment the nonce of the caller.
-func (k Keeper) EVMCallWithNonceIncrement(ctx context.Context, caller common.Address, contractAddr common.Address, inputBz []byte, value *uint256.Int) ([]byte, types.Logs, error) {
-	return k.EVMCallWithTracer(ctx, caller, contractAddr, inputBz, value, true, nil)
+	return k.EVMCallWithTracer(ctx, caller, contractAddr, inputBz, value, nil)
 }
 
 // EVMCallWithTracer executes an EVM call with the given input data and tracer.
-func (k Keeper) EVMCallWithTracer(ctx context.Context, caller common.Address, contractAddr common.Address, inputBz []byte, value *uint256.Int, increseNonce bool, tracer *tracing.Hooks) ([]byte, types.Logs, error) {
+func (k Keeper) EVMCallWithTracer(ctx context.Context, caller common.Address, contractAddr common.Address, inputBz []byte, value *uint256.Int, tracer *tracing.Hooks) ([]byte, types.Logs, error) {
 	ctx, evm, err := k.CreateEVM(ctx, caller, tracer)
 	if err != nil {
 		return nil, nil, err
@@ -249,9 +244,6 @@ func (k Keeper) EVMCallWithTracer(ctx context.Context, caller common.Address, co
 
 	rules := evm.ChainConfig().Rules(evm.Context.BlockNumber, evm.Context.Random != nil, evm.Context.Time)
 	evm.StateDB.Prepare(rules, caller, types.NullAddress, &contractAddr, append(vm.ActivePrecompiles(rules), k.precompiles.toAddrs()...), nil)
-	if increseNonce {
-		evm.StateDB.SetNonce(caller, evm.StateDB.GetNonce(caller)+1)
-	}
 
 	retBz, gasRemaining, err := evm.Call(
 		vm.AccountRef(caller),

x/evm/keeper/msg_server.go

@@ -142,13 +142,33 @@
 	}, nil
 }
 
+// increaseNonce increases the nonce of the given account.
+func (ms *msgServerImpl) increaseNonce(ctx context.Context, caller sdk.AccAddress) error {
+	senderAcc := ms.accountKeeper.GetAccount(ctx, caller)
+	if senderAcc == nil {
+		senderAcc = ms.accountKeeper.NewAccountWithAddress(ctx, caller)
+	}
+	if err := senderAcc.SetSequence(senderAcc.GetSequence() + 1); err != nil {
+		return err
+	}
+	ms.accountKeeper.SetAccount(ctx, senderAcc)
+	return nil
+}
+
 // Call implements types.MsgServer.
 func (ms *msgServerImpl) Call(ctx context.Context, msg *types.MsgCall) (*types.MsgCallResponse, error) {
 	sender, err := ms.ac.StringToBytes(msg.Sender)
 	if err != nil {
 		return nil, err
 	}
 
+	// increase nonce before execution like evm does
+	//
+	// NOTE: evm only increases nonce at Call not Create, so we should do the same.
+	if err := ms.increaseNonce(ctx, sender); err != nil {
+		return nil, err
+	}
+
 	contractAddr, err := types.ContractAddressFromString(ms.ac, msg.ContractAddr)
 	if err != nil {
 		return nil, err
@@ -168,7 +188,7 @@
 		return nil, types.ErrInvalidValue.Wrap("value is out of range")
 	}
 
-	retBz, logs, err := ms.EVMCallWithNonceIncrement(ctx, caller, contractAddr, inputBz, value)
+	retBz, logs, err := ms.EVMCall(ctx, caller, contractAddr, inputBz, value)
 	if err != nil {
 		return nil, types.ErrEVMCallFailed.Wrap(err.Error())
 	}

x/evm/keeper/query_server.go

@@ -83,7 +83,7 @@ func (qs *queryServerImpl) Call(ctx context.Context, req *types.QueryCallRequest
 		// if contract address is not provided, then it's a contract creation
 		retBz, _, logs, err = qs.EVMCreateWithTracer(sdkCtx, caller, inputBz, value, nil, tracer)
 	} else {
-		retBz, logs, err = qs.EVMCallWithTracer(sdkCtx, caller, contractAddr, inputBz, value, false, tracer)
+		retBz, logs, err = qs.EVMCallWithTracer(sdkCtx, caller, contractAddr, inputBz, value, tracer)
 
 	}
 

x/evm/state/keys.go

@@ -7,16 +7,11 @@ import (
 )
 
 var (
-	AccountKeyPrefix  = []byte("account")
 	CodeKeyPrefix     = []byte("code")
 	CodeSizeKeyPrefix = []byte("codesize")
 	StateKeyPrefix    = []byte("state")
 )
 
-func accountKey(addr common.Address) []byte {
-	return append(addr.Bytes(), AccountKeyPrefix...)
-}
-
 func codeKey(addr common.Address, codeHash []byte) []byte {
 	return append(addr.Bytes(), append(CodeKeyPrefix, codeHash...)...)
 }