feat: Add Preinstall Message Handler (#251)

Author: Eric-Warehime

api/cosmos/evm/vm/v1/tx.pulsar.go

@@ -140,10 +140,8 @@ func init() {
 
 const appName = "evmd"
 
-var (
-	// defaultNodeHome default home directories for the application daemon
-	defaultNodeHome string
-)
+// defaultNodeHome default home directories for the application daemon
+var defaultNodeHome string
 
 var (
 	_ runtime.AppI            = (*EVMD)(nil)

api/cosmos/evm/vm/v1/tx_grpc.pb.go

@@ -24,6 +24,12 @@ service Msg {
   // parameters. The authority is hard-coded to the Cosmos SDK x/gov module
   // account
   rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
+
+  // RegisterPreinstalls defines a governance operation for directly registering
+  // preinstalled contracts in the EVM. The authority is the same as is used for
+  // Params updates.
+  rpc RegisterPreinstalls(MsgRegisterPreinstalls)
+      returns (MsgRegisterPreinstallsResponse);
 }
 
 // MsgEthereumTx encapsulates an Ethereum transaction as an SDK message.
@@ -208,3 +214,20 @@ message MsgUpdateParams {
 // MsgUpdateParamsResponse defines the response structure for executing a
 // MsgUpdateParams message.
 message MsgUpdateParamsResponse {}
+
+// MsgRegisterPreinstalls defines a Msg for creating preinstalls in evm state.
+message MsgRegisterPreinstalls {
+  option (amino.name) = "cosmos/evm/x/vm/MsgRegisterPreinstalls";
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address of the governance account.
+  string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
+
+  // preinstalls defines the preinstalls to create.
+  repeated Preinstall preinstalls = 2
+      [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ];
+}
+
+// MsgRegisterPreinstallsResponse defines the response structure for executing a
+// MsgRegisterPreinstalls message.
+message MsgRegisterPreinstallsResponse {}

evmd/app.go

@@ -121,3 +121,60 @@ func (s *KeeperTestSuite) TestUpdateParams() {
 		s.Require().NoError(err)
 	}
 }
+
+func (s *KeeperTestSuite) TestRegisterPreinstalls() {
+	s.SetupTest()
+	testCases := []struct {
+		name        string
+		getMsg      func() *types.MsgRegisterPreinstalls
+		expectedErr error
+	}{
+		{
+			name: "fail - invalid authority",
+			getMsg: func() *types.MsgRegisterPreinstalls {
+				return &types.MsgRegisterPreinstalls{Authority: "foobar"}
+			},
+			expectedErr: govtypes.ErrInvalidSigner,
+		},
+		{
+			name: "pass - valid Update msg",
+			getMsg: func() *types.MsgRegisterPreinstalls {
+				return &types.MsgRegisterPreinstalls{
+					Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+					Preinstalls: []types.Preinstall{{
+						Name:    "Test1",
+						Address: "0xb364E75b1189DcbBF7f0C856456c1ba8e4d6481b",
+						Code:    "0x000000000",
+					}},
+				}
+			},
+			expectedErr: nil,
+		},
+		{
+			name: "fail - double registration",
+			getMsg: func() *types.MsgRegisterPreinstalls {
+				return &types.MsgRegisterPreinstalls{
+					Authority:   authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+					Preinstalls: types.DefaultPreinstalls,
+				}
+			},
+			expectedErr: types.ErrInvalidPreinstall,
+		},
+	}
+
+	for _, tc := range testCases {
+		s.Run("MsgRegisterPreinstalls_"+tc.name, func() {
+			msg := tc.getMsg()
+			_, err := s.Network.App.GetEVMKeeper().RegisterPreinstalls(s.Network.GetContext(), msg)
+			if tc.expectedErr != nil {
+				s.Require().Error(err)
+				s.Contains(err.Error(), tc.expectedErr.Error())
+			} else {
+				s.Require().NoError(err)
+			}
+		})
+
+		err := s.Network.NextBlock()
+		s.Require().NoError(err)
+	}
+}

proto/cosmos/evm/vm/v1/tx.proto

@@ -0,0 +1,111 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	cmttime "github.com/cometbft/cometbft/types/time"
+
+	vmkeeper "github.com/cosmos/evm/x/vm/keeper"
+	vmtypes "github.com/cosmos/evm/x/vm/types"
+	"github.com/cosmos/evm/x/vm/types/mocks"
+
+	storetypes "cosmossdk.io/store/types"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+type KeeperTestSuite struct {
+	suite.Suite
+
+	ctx           sdk.Context
+	bankKeeper    *mocks.BankKeeper
+	accKeeper     *mocks.AccountKeeper
+	stakingKeeper *mocks.StakingKeeper
+	fmKeeper      *mocks.FeeMarketKeeper
+	erc20Keeper   *mocks.Erc20Keeper
+	vmKeeper      *vmkeeper.Keeper
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+	suite.Run(t, new(KeeperTestSuite))
+}
+
+func (suite *KeeperTestSuite) SetupTest() {
+	key := storetypes.NewKVStoreKey(vmtypes.StoreKey)
+	transientKey := storetypes.NewTransientStoreKey(vmtypes.TransientKey)
+	testCtx := testutil.DefaultContextWithDB(suite.T(), key, storetypes.NewTransientStoreKey("transient_test"))
+	ctx := testCtx.Ctx.WithBlockHeader(cmtproto.Header{Time: cmttime.Now()})
+	encCfg := moduletestutil.MakeTestEncodingConfig()
+
+	// storeService := runtime.NewKVStoreService(key)
+	authority := sdk.AccAddress("foobar")
+
+	suite.bankKeeper = mocks.NewBankKeeper(suite.T())
+	suite.accKeeper = mocks.NewAccountKeeper(suite.T())
+	suite.stakingKeeper = mocks.NewStakingKeeper(suite.T())
+	suite.fmKeeper = mocks.NewFeeMarketKeeper(suite.T())
+	suite.erc20Keeper = mocks.NewErc20Keeper(suite.T())
+	suite.ctx = ctx
+
+	suite.accKeeper.On("GetModuleAddress", vmtypes.ModuleName).Return(sdk.AccAddress("evm"))
+	suite.vmKeeper = vmkeeper.NewKeeper(
+		encCfg.Codec,
+		key,
+		transientKey,
+		authority,
+		suite.accKeeper,
+		suite.bankKeeper,
+		suite.stakingKeeper,
+		suite.fmKeeper,
+		suite.erc20Keeper,
+		"",
+	)
+}
+
+func (suite *KeeperTestSuite) TestAddPreinstalls() {
+	testCases := []struct {
+		name        string
+		malleate    func()
+		preinstalls []vmtypes.Preinstall
+		err         error
+	}{
+		{
+			"Default pass",
+			func() {
+				suite.accKeeper.On("GetAccount", mock.Anything, mock.Anything).Return(nil)
+				suite.accKeeper.On("NewAccountWithAddress", mock.Anything,
+					mock.Anything).Return(authtypes.NewBaseAccountWithAddress(sdk.AccAddress("evm")), nil)
+				suite.accKeeper.On("SetAccount", mock.Anything, mock.Anything).Return()
+			},
+			vmtypes.DefaultPreinstalls,
+			nil,
+		},
+		{
+			"Acc already exists -- expect error",
+			func() {
+				suite.accKeeper.ExpectedCalls = suite.accKeeper.ExpectedCalls[:0]
+				suite.accKeeper.On("GetAccount", mock.Anything, mock.Anything).Return(authtypes.NewBaseAccountWithAddress(sdk.AccAddress("evm")))
+			},
+			vmtypes.DefaultPreinstalls,
+			vmtypes.ErrInvalidPreinstall,
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			tc.malleate()
+			err := suite.vmKeeper.AddPreinstalls(suite.ctx, vmtypes.DefaultPreinstalls)
+			if tc.err != nil {
+				suite.Require().ErrorContains(err, tc.err.Error())
+			} else {
+				suite.Require().NoError(err)
+			}
+		})
+	}
+}

tests/integration/x/vm/test_msg_server.go

@@ -146,3 +146,22 @@ func (k *Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams)
 
 	return &types.MsgUpdateParamsResponse{}, nil
 }
+
+// RegisterPreinstalls implements the gRPC MsgServer interface. When a RegisterPreinstalls
+// proposal passes, it creates the preinstalls. The registration can only be
+// performed if the requested authority is the Cosmos SDK governance module
+// account.
+func (k *Keeper) RegisterPreinstalls(goCtx context.Context, req *types.MsgRegisterPreinstalls) (*types.
+	MsgRegisterPreinstallsResponse, error,
+) {
+	if k.authority.String() != req.Authority {
+		return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority, expected %s, got %s", k.authority.String(), req.Authority)
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	if err := k.AddPreinstalls(ctx, req.Preinstalls); err != nil {
+		return nil, err
+	}
+
+	return &types.MsgRegisterPreinstallsResponse{}, nil
+}

x/erc20/types/mocks/EVMKeeper.go

@@ -33,12 +33,12 @@ func (k *Keeper) AddPreinstalls(ctx sdk.Context, preinstalls []types.Preinstall)
 		}
 
 		// check that the account is not already set
-		if exists := k.accountKeeper.HasAccount(ctx, accAddress); !exists {
-			// return errorsmod.Wrapf(types.ErrInvalidPreinstall, "preinstall %s already has an account in account keeper", preinstall.Address.String())
-			// create account with the account keeper
-			account := k.accountKeeper.NewAccountWithAddress(ctx, accAddress)
-			k.accountKeeper.SetAccount(ctx, account)
+		if acc := k.accountKeeper.GetAccount(ctx, accAddress); acc != nil {
+			return errorsmod.Wrapf(types.ErrInvalidPreinstall, "preinstall %s already has an account in account keeper", preinstall.Address)
 		}
+		// create account with the account keeper
+		account := k.accountKeeper.NewAccountWithAddress(ctx, accAddress)
+		k.accountKeeper.SetAccount(ctx, account)
 
 		k.SetCodeHash(ctx, address.Bytes(), codeHash)
 

x/vm/keeper/keeper_test.go

@@ -27,7 +27,7 @@ import (
 )
 
 // consensusVersion defines the current x/evm module consensus version.
-const consensusVersion = 10
+const consensusVersion = 9
 
 var (
 	_ module.AppModuleBasic = AppModuleBasic{}