imp(staking): implement the CreateValidator function for staking precompiled contract

CHANGELOG.md

@@ -83,6 +83,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - (osmosis-outpost) [#2017](https://github.com/evmos/evmos/pull/2017) Refactor types, errors and precompile struct.
 - (erc20) [#2023](https://github.com/evmos/evmos/pull/2023) Add tests for ERC20 precompile queries.
 - (osmosis-outpost) [#2025](https://github.com/evmos/evmos/pull/2025) Use a struct to wrap parsed parameters from Solidity.
+- (staking) [#2030](https://github.com/evmos/evmos/pull/2030) Implement the `CreateValidator` function for staking precompiled contract.
 
 ### Bug Fixes
 

precompiles/staking/StakingI.sol

@@ -11,11 +11,22 @@ address constant STAKING_PRECOMPILE_ADDRESS = 0x00000000000000000000000000000000
 StakingI constant STAKING_CONTRACT = StakingI(STAKING_PRECOMPILE_ADDRESS);
 
 /// @dev Define all the available staking methods.
+string constant MSG_CREATE_VALIDATOR = "/cosmos.staking.v1beta1.MsgCreateValidator";
 string constant MSG_DELEGATE = "/cosmos.staking.v1beta1.MsgDelegate";
 string constant MSG_UNDELEGATE = "/cosmos.staking.v1beta1.MsgUndelegate";
 string constant MSG_REDELEGATE = "/cosmos.staking.v1beta1.MsgBeginRedelegate";
 string constant MSG_CANCEL_UNDELEGATION = "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation";
 
+/// @dev Defines the initial description to be used for creating
+/// a validator.
+struct Description {
+    string moniker;
+    string identity;
+    string website;
+    string securityContact;
+    string details;
+}
+
 /// @dev Defines the initial commission rates to be used for creating
 /// a validator.
 struct CommissionRates {
@@ -114,6 +125,25 @@ enum BondStatus {
 /// wraps the pallet.
 /// @custom:address 0x0000000000000000000000000000000000000800
 interface StakingI is authorization.AuthorizationI {
+    /// @dev Defines a method for creating a new validator.
+    /// @param description The initial description
+    /// @param commissionRates The initial commissionRates
+    /// @param minSelfDelegation The validator's self declared minimum self delegation
+    /// @param delegatorAddress The delegator address
+    /// @param validatorAddress The validator address
+    /// @param pubkey The consensus public key of the validator
+    /// @param value The amount of the coin to be self delegated to the validator
+    /// @return success Whether or not the create validator was successful
+    function createValidator(
+        Description calldata description,
+        CommissionRates calldata commissionRates,
+        uint256 minSelfDelegation,
+        address delegatorAddress,
+        string memory validatorAddress,
+        string memory pubkey,
+        uint256 value
+    ) external returns (bool success);
+
     /// @dev Defines a method for performing a delegation of coins from a delegator to a validator.
     /// @param delegatorAddress The address of the delegator
     /// @param validatorAddress The address of the validator
@@ -238,6 +268,26 @@ interface StakingI is authorization.AuthorizationI {
             PageResponse calldata pageResponse
         );
 
+    /// @dev CreateValidator defines an Event emitted when a create a new validator.
+    /// @param delegatorAddress The address of the delegator
+    /// @param validatorAddress The address of the validator
+    /// @param commissionRate The commission rate charged to delegators, as a fraction
+    /// @param commissionMaxRate The commission max rate charged to delegators, as a fraction
+    /// @param commissionMaxChangeRate The commission max change rate charged to delegators, as a fraction
+    /// @param minSelfDelegation The validator's self declared minimum self delegation
+    /// @param pubkey The consensus public key of the validator
+    /// @param value The amount of coin being self delegated
+    event CreateValidator(
+        address indexed delegatorAddress,
+        string indexed validatorAddress,
+        uint256 commissionRate,
+        uint256 commissionMaxRate,
+        uint256 commissionMaxChangeRate,
+        uint256 minSelfDelegation,
+        string pubkey,
+        uint256 value
+    );
+
     /// @dev Delegate defines an Event emitted when a given amount of tokens are delegated from the
     /// delegator address to the validator address.
     /// @param delegatorAddress The address of the delegator

precompiles/staking/abi.json

@@ -92,6 +92,61 @@
     "name": "CancelUnbondingDelegation",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "delegatorAddress",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "string",
+        "name": "validatorAddress",
+        "type": "string"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "commissionRate",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "commissionMaxRate",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "commissionMaxChangeRate",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "minSelfDelegation",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "string",
+        "name": "pubkey",
+        "type": "string"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "CreateValidator",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -308,6 +363,99 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "string",
+            "name": "moniker",
+            "type": "string"
+          },
+          {
+            "internalType": "string",
+            "name": "identity",
+            "type": "string"
+          },
+          {
+            "internalType": "string",
+            "name": "website",
+            "type": "string"
+          },
+          {
+            "internalType": "string",
+            "name": "securityContact",
+            "type": "string"
+          },
+          {
+            "internalType": "string",
+            "name": "details",
+            "type": "string"
+          }
+        ],
+        "internalType": "struct Description",
+        "name": "description",
+        "type": "tuple"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "rate",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "maxRate",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "maxChangeRate",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct CommissionRates",
+        "name": "commissionRates",
+        "type": "tuple"
+      },
+      {
+        "internalType": "uint256",
+        "name": "minSelfDelegation",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "delegatorAddress",
+        "type": "address"
+      },
+      {
+        "internalType": "string",
+        "name": "validatorAddress",
+        "type": "string"
+      },
+      {
+        "internalType": "string",
+        "name": "pubkey",
+        "type": "string"
+      },
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "createValidator",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "success",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {

precompiles/staking/events.go

@@ -20,6 +20,8 @@
 )
 
 const (
+	// EventTypeCreateValidator defines the event type for the staking CreateValidator transaction.
+	EventTypeCreateValidator = "CreateValidator"
 	// EventTypeDelegate defines the event type for the staking Delegate transaction.
 	EventTypeDelegate = "Delegate"
 	// EventTypeUnbond defines the event type for the staking Undelegate transaction.
@@ -122,6 +124,46 @@
 	return nil
 }
 
+// EmitCreateValidatorEvent creates a new ctreate valdator event emitted on a CreateValidator transaction.
+func (p Precompile) EmitCreateValidatorEvent(ctx sdk.Context, stateDB vm.StateDB, msg *stakingtypes.MsgCreateValidator, delegatorAddr common.Address) error {
+	// Prepare the event topics
+	event := p.ABI.Events[EventTypeCreateValidator]
+	topics, err := p.createStakingTxTopics(3, event, delegatorAddr, msg.ValidatorAddress)
+	if err != nil {
+		return err
+	}
+
+	// Pack the arguments to be used as the Data field
+	arguments := abi.Arguments{
+		event.Inputs[2],
+		event.Inputs[3],
+		event.Inputs[4],
+		event.Inputs[5],
+		event.Inputs[6],
+		event.Inputs[7],
+	}
+	packed, err := arguments.Pack(
+		msg.Commission.Rate.BigInt(),
+		msg.Commission.MaxRate.BigInt(),
+		msg.Commission.MaxChangeRate.BigInt(),
+		msg.MinSelfDelegation.BigInt(),
+		msg.Pubkey.String(),
+		msg.Value.Amount.BigInt(),
+	)
+	if err != nil {
+		return err
+	}
+
+	stateDB.AddLog(&ethtypes.Log{
+		Address:     p.Address(),
+		Topics:      topics,
+		Data:        packed,
+		BlockNumber: uint64(ctx.BlockHeight()),
+	})
+
+	return nil
+}
+
 // EmitDelegateEvent creates a new delegate event emitted on a Delegate transaction.
 func (p Precompile) EmitDelegateEvent(ctx sdk.Context, stateDB vm.StateDB, msg *stakingtypes.MsgDelegate, delegatorAddr common.Address) error {
 	valAddr, err := sdk.ValAddressFromBech32(msg.ValidatorAddress)

precompiles/staking/staking.go

@@ -109,6 +109,8 @@
 	case authorization.DecreaseAllowanceMethod:
 		bz, err = p.DecreaseAllowance(ctx, evm.Origin, stateDB, method, args)
 	// Staking transactions
+	case CreateValidatorMethod:
+		bz, err = p.CreateValidator(ctx, evm.Origin, contract, stateDB, method, args)
 	case DelegateMethod:
 		bz, err = p.Delegate(ctx, evm.Origin, contract, stateDB, method, args)
 	case UndelegateMethod:

precompiles/staking/tx.go

@@ -30,6 +30,8 @@
 	// CancelUnbondingDelegationMethod defines the ABI method name for the staking
 	// CancelUnbondingDelegation transaction.
 	CancelUnbondingDelegationMethod = "cancelUnbondingDelegation"
+	// CreateValidatorMethod defines the ABI method name for the staking create validator transaction
+	CreateValidatorMethod = "createValidator"
 )
 
 const (
@@ -43,6 +45,52 @@
 	CancelUnbondingDelegationAuthz = stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION
 )
 
+// CreateValidator performs create validator.
+func (p Precompile) CreateValidator(
+	ctx sdk.Context,
+	origin common.Address,
+	contract *vm.Contract,
+	stateDB vm.StateDB,
+	method *abi.Method,
+	args []interface{},
+) ([]byte, error) {
+	msg, delegatorHexAddr, err := NewMsgCreateValidator(args, p.stakingKeeper.BondDenom(ctx))
+	if err != nil {
+		return nil, err
+	}
+
+	p.Logger(ctx).Debug(
+		"tx called",
+		"method", method.Name,
+		"args", fmt.Sprintf(
+			"{ min_self_delegation: %s, delegator_address: %s, validator_address: %s, pubkey: %s, value: %s }",
+			msg.MinSelfDelegation.String(),
+			delegatorHexAddr,
+			msg.ValidatorAddress,
+			msg.Pubkey.String(),
+			msg.Value.Amount.String(),
+		),
+	)
+
+	// We only allow users to directly call the StakingI contract's address which is 0x0000000000000000000000000000000000000800 to create a new validator.
+	if origin != delegatorHexAddr {
+		return nil, fmt.Errorf(ErrDifferentOriginFromDelegator, origin.String(), delegatorHexAddr.String())
+	}
+
+	// Execute the transaction using the message server
+	msgSrv := stakingkeeper.NewMsgServerImpl(&p.stakingKeeper)
+	if _, err = msgSrv.CreateValidator(sdk.WrapSDKContext(ctx), msg); err != nil {
+		return nil, err
+	}
+
+	// Emit the event for the delegate transaction
+	if err = p.EmitCreateValidatorEvent(ctx, stateDB, msg, delegatorHexAddr); err != nil {
+		return nil, err
+	}
+
+	return method.Outputs.Pack(true)
+}
+
 // Delegate performs a delegation of coins from a delegator to a validator.
 func (p Precompile) Delegate(
 	ctx sdk.Context,