fix: EoA-CA Identification logic (#710)

Author: cloudgray

CHANGELOG.md

@@ -54,6 +54,8 @@
 - [\#701](https://github.com/cosmos/evm/pull/701) Add address codec support to ERC20 IBC callbacks to handle hex addresses in addition to bech32 addresses.
 - [\#702](https://github.com/cosmos/evm/pull/702) Fix mempool e2e test
 - [\#704](https://github.com/cosmos/evm/pull/704) Fix EIP-7702 test cases
+- [\#706](https://github.com/cosmos/evm/pull/706) Fix EoA-CA Identification logic
+
 
 ### FEATURES
 

ante/evm/06_account_verification.go

@@ -29,7 +29,7 @@ func VerifyAccountBalance(
 	ethTx *ethtypes.Transaction,
 ) error {
 	// Only EOA are allowed to send transactions.
-	if account != nil && account.IsContract() {
+	if account != nil && account.HasCodeHash() {
 		// check eip-7702
 		code := evmKeeper.GetCode(ctx, common.BytesToHash(account.CodeHash))
 		_, delegated := ethtypes.ParseDelegation(code)

precompiles/staking/tx.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 
 	cmn "github.com/cosmos/evm/precompiles/common"
@@ -59,10 +60,16 @@ func (p Precompile) CreateValidator(
 	)
 
 	msgSender := contract.Caller()
-	// we won't allow calls from smart contracts
-	if hasCode := stateDB.GetCode(msgSender) != nil; hasCode {
+
+	// We won't allow calls from smart contracts
+	// unless they are EIP-7702 delegated accounts
+	code := stateDB.GetCode(msgSender)
+	_, delegated := ethtypes.ParseDelegation(code)
+	if len(code) > 0 && !delegated {
+		// call by contract method
 		return nil, errors.New(ErrCannotCallFromContract)
 	}
+
 	if msgSender != validatorHexAddr {
 		return nil, fmt.Errorf(cmn.ErrRequesterIsNotMsgSender, msgSender.String(), validatorHexAddr.String())
 	}
@@ -105,10 +112,16 @@ func (p Precompile) EditValidator(
 	)
 
 	msgSender := contract.Caller()
-	// we won't allow calls from smart contracts
-	if hasCode := stateDB.GetCode(msgSender) != nil; hasCode {
+
+	// We won't allow calls from smart contracts
+	// unless they are EIP-7702 delegated accounts
+	code := stateDB.GetCode(msgSender)
+	_, delegated := ethtypes.ParseDelegation(code)
+	if len(code) > 0 && !delegated {
+		// call by contract method
 		return nil, errors.New(ErrCannotCallFromContract)
 	}
+
 	if msgSender != validatorHexAddr {
 		return nil, fmt.Errorf(cmn.ErrRequesterIsNotMsgSender, msgSender.String(), validatorHexAddr.String())
 	}

tests/integration/precompiles/distribution/test_integration.go

@@ -1343,7 +1343,8 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 			// check contract was correctly deployed
 			cAcc := s.network.App.GetEVMKeeper().GetAccount(s.network.GetContext(), contractAddr)
 			Expect(cAcc).ToNot(BeNil(), "contract account should exist")
-			Expect(cAcc.IsContract()).To(BeTrue(), "account should be a contract")
+			isContract := s.network.App.GetEVMKeeper().IsContract(s.network.GetContext(), contractAddr)
+			Expect(isContract).To(BeTrue(), "account should be a contract")
 
 			// Contract delegate
 			stkPrecompile := s.getStakingPrecompile()

tests/integration/precompiles/gov/test_integration.go

@@ -1052,7 +1052,8 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 
 			cAcc := s.network.App.GetEVMKeeper().GetAccount(s.network.GetContext(), contractAddr)
 			Expect(cAcc).ToNot(BeNil(), "failed to get contract account")
-			Expect(cAcc.IsContract()).To(BeTrue(), "expected contract account")
+			isContract := s.network.App.GetEVMKeeper().IsContract(s.network.GetContext(), contractAddr)
+			Expect(isContract).To(BeTrue(), "expected contract account")
 
 			contractAddrDupe, err = s.factory.DeployContract(
 				txSenderKey,
@@ -1067,7 +1068,8 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 
 			cAccDupe := s.network.App.GetEVMKeeper().GetAccount(s.network.GetContext(), contractAddrDupe)
 			Expect(cAccDupe).ToNot(BeNil(), "failed to get dupe contract account")
-			Expect(cAccDupe.IsContract()).To(BeTrue(), "expected dupe contract account")
+			isContract = s.network.App.GetEVMKeeper().IsContract(s.network.GetContext(), contractAddrDupe)
+			Expect(isContract).To(BeTrue(), "expected dupe contract account")
 
 			callArgs = testutiltypes.CallArgs{
 				ContractABI: govCallerContract.ABI,

tests/integration/precompiles/slashing/test_integration.go

@@ -85,7 +85,8 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 			// check contract was correctly deployed
 			cAcc := s.network.App.GetEVMKeeper().GetAccount(s.network.GetContext(), contractAddr)
 			Expect(cAcc).ToNot(BeNil(), "contract account should exist")
-			Expect(cAcc.IsContract()).To(BeTrue(), "account should be a contract")
+			isContract := s.network.App.GetEVMKeeper().IsContract(s.network.GetContext(), contractAddr)
+			Expect(isContract).To(BeTrue(), "account should be a contract")
 
 			// populate default call args
 			callArgs = testutiltypes.CallArgs{

tests/integration/precompiles/staking/test_integration.go

@@ -1440,7 +1440,8 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 			// check contract was correctly deployed
 			cAcc := s.network.App.GetEVMKeeper().GetAccount(s.network.GetContext(), contractAddr)
 			Expect(cAcc).ToNot(BeNil(), "contract account should exist")
-			Expect(cAcc.IsContract()).To(BeTrue(), "account should be a contract")
+			isContract := s.network.App.GetEVMKeeper().IsContract(s.network.GetContext(), contractAddr)
+			Expect(isContract).To(BeTrue(), "account should be a contract")
 
 			// populate default TxArgs
 			txArgs.To = &contractAddr
@@ -1565,6 +1566,36 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 				Expect(err).NotTo(BeNil(), "expected validator NOT to be found")
 				Expect(err.Error()).To(ContainSubstring("not found"), "expected validator NOT to be found")
 			})
+
+			It("tx from validator operator with delegated code - should create a validator", func() {
+				s.delegateAccountToContract(valPriv, valHexAddr, contractTwoAddr)
+
+				callArgs = testutiltypes.CallArgs{
+					ContractABI: stakingCallerTwoContract.ABI,
+					MethodName:  "testCreateValidatorWithTransfer",
+					Args: []interface{}{
+						defaultDescription, defaultCommission, defaultMinSelfDelegation, valHexAddr, defaultPubkeyBase64Str, false, false,
+					},
+				}
+
+				txArgs = evmtypes.EvmTxArgs{
+					To:       &valHexAddr,
+					GasLimit: 500_000,
+					Amount:   new(big.Int).Set(defaultValue),
+				}
+
+				_, _, err = s.factory.CallContractAndCheckLogs(
+					valPriv,
+					txArgs, callArgs,
+					passCheck.WithExpEvents(staking.EventTypeCreateValidator),
+				)
+				Expect(err).To(BeNil(), "error while calling the smart contract")
+				Expect(s.network.NextBlock()).To(BeNil())
+
+				qc := s.network.GetStakingClient()
+				_, err := qc.Validator(s.network.GetContext(), &stakingtypes.QueryValidatorRequest{ValidatorAddr: sdk.ValAddress(valAddr).String()})
+				Expect(err).To(BeNil(), "expected validator NOT to be found")
+			})
 		})
 
 		Context("to edit a validator", func() {
@@ -1683,6 +1714,33 @@ func TestPrecompileIntegrationTestSuite(t *testing.T, create network.CreateEvmAp
 				Expect(validator.Description.Moniker).To(Equal("original moniker"), "expected validator moniker is updated")
 				Expect(validator.Commission.Rate.BigInt().String()).To(Equal("100000000000000000"), "expected validator commission rate remain unchanged")
 			})
+
+			It("with tx from validator operator using delegated code - should NOT edit a validator", func() {
+				s.delegateAccountToContract(valPriv, valHexAddr, contractAddr)
+				callArgs.Args = []interface{}{
+					defaultDescription, valHexAddr,
+					defaultCommissionRate, defaultMinSelfDelegation,
+				}
+
+				txArgs.To = &valHexAddr
+
+				_, _, err = s.factory.CallContractAndCheckLogs(
+					valPriv,
+					txArgs,
+					callArgs,
+					execRevertedCheck,
+				)
+				Expect(err).To(BeNil(), "error while calling the smart contract")
+				Expect(s.network.NextBlock()).To(BeNil())
+
+				qc := s.network.GetStakingClient()
+				qRes, err := qc.Validator(s.network.GetContext(), &stakingtypes.QueryValidatorRequest{ValidatorAddr: sdk.ValAddress(valAddr).String()})
+				Expect(err).To(BeNil())
+				Expect(qRes).NotTo(BeNil())
+
+				validator := qRes.Validator
+				Expect(validator.Description.Moniker).NotTo(Equal(defaultDescription.Moniker), "expected validator moniker NOT to be updated")
+			})
 		})
 
 		Context("delegating", func() {

tests/integration/precompiles/staking/test_tx.go

@@ -245,6 +245,25 @@ func (s *PrecompileTestSuite) TestCreateValidator() {
 			true,
 			"does not match the requester address",
 		},
+		{
+			"fail - cannot be called from account with code (if it is not EIP-7702 delegated account)",
+			func() []interface{} {
+				stDB.SetCode(validatorAddress, []byte{0x60, 0x00})
+				return []interface{}{
+					description,
+					commission,
+					minSelfDelegation,
+					validatorAddress,
+					pubkey,
+					value,
+				}
+			},
+			200000,
+			nil,
+			func([]byte) {},
+			true,
+			staking.ErrCannotCallFromContract,
+		},
 		{
 			"success",
 			func() []interface{} {
@@ -522,7 +541,7 @@ func (s *PrecompileTestSuite) TestEditValidator() {
 			"minimum self delegation must be a positive integer",
 		},
 		{
-			"fail - calling precompile from a different address than validator (smart contract call)",
+			"fail - cannot be called from account with code (if it is not EIP-7702 delegated account)",
 			func() []interface{} {
 				return []interface{}{
 					description,
@@ -540,6 +559,23 @@ func (s *PrecompileTestSuite) TestEditValidator() {
 			true,
 			"does not match the requester address",
 		},
+		{
+			"fail - cannot be called from smart contract",
+			func() []interface{} {
+				stDB.SetCode(validatorAddress, []byte{0x60, 0x00})
+				return []interface{}{
+					description,
+					validatorAddress,
+					commissionRate,
+					minSelfDelegation,
+				}
+			},
+			200000,
+			nil,
+			func([]byte) {},
+			true,
+			staking.ErrCannotCallFromContract,
+		},
 		{
 			"success",
 			func() []interface{} {

tests/integration/precompiles/staking/test_utils.go

@@ -7,15 +7,20 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	gethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/holiman/uint256"
 
 	//nolint:revive // dot imports are fine for Ginkgo
 	. "github.com/onsi/gomega"
 
+	"github.com/cosmos/evm/crypto/ethsecp256k1"
 	"github.com/cosmos/evm/precompiles/staking"
+	evmtypes "github.com/cosmos/evm/x/vm/types"
 
 	"cosmossdk.io/math"
 
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
@@ -153,3 +158,44 @@ func GenerateBase64PubKey() string {
 	pubKey := privKey.PubKey().(*ed25519.PubKey)
 	return base64.StdEncoding.EncodeToString(pubKey.Bytes())
 }
+
+// delegateAccountToContract delegates the given account to the given contract address using
+// the EIP-7702 SetCodeTx.
+func (s *PrecompileTestSuite) delegateAccountToContract(privKey cryptotypes.PrivKey, accountAddr, contractAddr common.Address) {
+	ethPriv, ok := privKey.(*ethsecp256k1.PrivKey)
+	Expect(ok).To(BeTrue(), "expected ethsecp256k1 private key")
+	ecdsaPriv, err := ethPriv.ToECDSA()
+	Expect(err).To(BeNil(), "error converting to ECDSA private key")
+
+	chainID := evmtypes.GetChainConfig().GetChainId()
+	accResp, err := s.grpcHandler.GetEvmAccount(accountAddr)
+	Expect(err).To(BeNil(), "error while getting the EVM account")
+
+	nonce := accResp.GetNonce()
+
+	authorization := gethtypes.SetCodeAuthorization{
+		ChainID: *uint256.NewInt(chainID),
+		Address: contractAddr,
+		Nonce:   nonce + 1,
+	}
+
+	signedAuth, err := gethtypes.SignSetCode(ecdsaPriv, authorization)
+	Expect(err).To(BeNil(), "error while signing the SetCodeAuthorization")
+
+	txArgs := evmtypes.EvmTxArgs{
+		To:       &common.Address{},
+		GasLimit: 500_000,
+		AuthorizationList: []gethtypes.SetCodeAuthorization{
+			signedAuth,
+		},
+	}
+
+	_, err = s.factory.ExecuteEthTx(privKey, txArgs)
+	Expect(err).To(BeNil(), "error while executing the SetCode transaction")
+	Expect(s.network.NextBlock()).To(BeNil(), "failed to advance block")
+
+	codeHash := s.network.App.GetEVMKeeper().GetCodeHash(s.network.GetContext(), accountAddr)
+	code := s.network.App.GetEVMKeeper().GetCode(s.network.GetContext(), codeHash)
+	_, delegated := gethtypes.ParseDelegation(code)
+	Expect(delegated).To(BeTrue(), "expected account to be delegated to the contract address")
+}

tests/integration/x/erc20/test_ibc_callback.go

@@ -233,7 +233,8 @@ func (s *KeeperTestSuite) TestOnRecvPacketRegistered() {
 					CodeHash: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 				})
 				s.Require().NoError(err)
-				s.Require().True(s.network.App.GetEVMKeeper().IsContract(ctx, collidedAddr))
+				acct := s.network.App.GetEVMKeeper().GetAccount(ctx, collidedAddr)
+				s.Require().True(acct.HasCodeHash())
 			},
 			ackSuccess:    false,
 			receiver:      secpAddr,