fix: re add operation.go

Author: ecPablo

mcms/evm/grant-role/operation.go

@@ -1,33 +1,139 @@
 package evmgrantrole
 
 import (
+	"errors"
+	"fmt"
+	"math/big"
+
 	"github.com/Masterminds/semver/v3"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-
+	cldf_evm "github.com/smartcontractkit/chainlink-deployments-framework/chain/evm"
+	opscontract "github.com/smartcontractkit/chainlink-deployments-framework/chain/evm/operations2/contract"
+	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
 	mcmscontracts "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/contracts/mcms"
-	"github.com/smartcontractkit/mcms/sdk/evm/bindings"
+	cldfproposalutils "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/mcms/proposalutils"
+	"github.com/smartcontractkit/chainlink-deployments-framework/operations"
+	mcmssdk "github.com/smartcontractkit/mcms/sdk"
+	mcmsevm "github.com/smartcontractkit/mcms/sdk/evm"
+	mcmsbindings "github.com/smartcontractkit/mcms/sdk/evm/bindings"
 
-	evmops "github.com/smartcontractkit/cld-changesets/legacy/mcms/oputils"
+	"github.com/smartcontractkit/cld-changesets/mcms/evm/internal/gasboost"
 )
 
-// OpGrantRoleInput is the input to OpGrantRole.
-type OpGrantRoleInput struct {
-	Account common.Address `json:"account"`
-	RoleID  [32]byte       `json:"roleID"`
+type GrantRoleTarget struct {
+	Timelock common.Address       `json:"timelock"`
+	Role     mcmssdk.TimelockRole `json:"role"`
+	Address  common.Address       `json:"address"`
+}
+
+type OpEVMGrantRoleInput struct {
+	Target   GrantRoleTarget `json:"target"`
+	NoSend   bool            `json:"noSend"`
+	GasPrice uint64          `json:"gasPrice"`
+	GasLimit uint64          `json:"gasLimit"`
 }
 
-// OpGrantRole grants the given role to the given account on the EVM Timelock contract.
-// TODO: refactor to use mcms lib
-var OpGrantRole = evmops.NewEVMCallOperation(
+func (in OpEVMGrantRoleInput) GasBoostValues() (gasLimit, gasPrice uint64) {
+	return in.GasLimit, in.GasPrice
+}
+
+func (in OpEVMGrantRoleInput) WithGasBoost(gasLimit, gasPrice uint64) OpEVMGrantRoleInput {
+	in.GasLimit = gasLimit
+	in.GasPrice = gasPrice
+
+	return in
+}
+
+var OpEVMGrantRole = operations.NewOperation(
 	"evm-timelock-grant-role",
 	semver.MustParse("1.0.0"),
-	"Grants the specified role to the given account on the EVM Timelock contract",
-	bindings.RBACTimelockABI,
-	mcmscontracts.RBACTimelock,
-	bindings.NewRBACTimelock,
-	func(timelock *bindings.RBACTimelock, opts *bind.TransactOpts, input OpGrantRoleInput) (*types.Transaction, error) {
-		return timelock.GrantRole(opts, input.RoleID, input.Account)
+	"Grants an RBACTimelock role to one EVM address via the MCMS SDK timelock configurer",
+	func(b operations.Bundle, deps cldf_evm.Chain, in OpEVMGrantRoleInput) (opscontract.WriteOutput, error) {
+		if !in.NoSend && deps.DeployerKey == nil {
+			return opscontract.WriteOutput{}, fmt.Errorf("missing deployer key for chain %d", deps.Selector)
+		}
+
+		var opts *bind.TransactOpts
+		if in.NoSend {
+			opts = cldf.SimTransactOpts()
+		} else {
+			opts = gasboost.CloneTransactOptsWithGas(deps.DeployerKey, in.GasLimit, in.GasPrice)
+		}
+		if opts == nil {
+			return opscontract.WriteOutput{}, fmt.Errorf("failed to build transact opts for chain %d", deps.Selector)
+		}
+		opts.Context = b.GetContext()
+
+		configurer := mcmsevm.NewTimelockConfigurer(deps.Client, opts)
+		res, err := configurer.GrantRole(b.GetContext(), in.Target.Timelock.Hex(), in.Target.Role, in.Target.Address.Hex())
+		if err != nil {
+			return opscontract.WriteOutput{}, fmt.Errorf("failed to grant role %s to %s on %s: %w",
+				in.Target.Role.String(), in.Target.Address.Hex(), in.Target.Timelock.Hex(), err)
+		}
+
+		tx, err := rawTransaction(res.RawData)
+		if err != nil {
+			return opscontract.WriteOutput{}, err
+		}
+
+		out := writeOutputFromGrant(deps.Selector, in.Target.Timelock, tx)
+		if in.NoSend {
+			return out, nil
+		}
+
+		if _, err = cldf.ConfirmIfNoErrorWithABI(deps, tx, mcmsbindings.RBACTimelockABI, nil); err != nil {
+			return opscontract.WriteOutput{}, fmt.Errorf("failed to confirm grant role tx against %s: %w", in.Target.Timelock.Hex(), err)
+		}
+		b.Logger.Infow("GrantRole tx confirmed", "txHash", tx.Hash().Hex(), "timelock", in.Target.Timelock.Hex())
+
+		out.ExecInfo = &opscontract.ExecInfo{Hash: tx.Hash().Hex()}
+
+		return out, nil
 	},
 )
+
+func writeOutputFromGrant(chainSelector uint64, timelock common.Address, tx *types.Transaction) opscontract.WriteOutput {
+	return opscontract.WriteOutput{
+		ChainSelector: chainSelector,
+		Tx: mcmsevm.NewTransaction(
+			timelock,
+			tx.Data(),
+			big.NewInt(0),
+			string(mcmscontracts.RBACTimelock),
+			[]string{},
+		),
+	}
+}
+
+func rawTransaction(raw any) (*types.Transaction, error) {
+	switch tx := raw.(type) {
+	case *types.Transaction:
+		return tx, nil
+	default:
+		return nil, fmt.Errorf("unexpected raw data type %T from GrantRole", raw)
+	}
+}
+
+func retryGrantRoleWithGasBoost(cfg *cldfproposalutils.GasBoostConfig) operations.ExecuteOption[OpEVMGrantRoleInput, cldf_evm.Chain] {
+	if cfg == nil {
+		return operations.WithRetry[OpEVMGrantRoleInput, cldf_evm.Chain]()
+	}
+
+	return gasboost.RetryWithGasBoost[OpEVMGrantRoleInput](cfg)
+}
+
+func validateGrantRoleTarget(target GrantRoleTarget) error {
+	if target.Timelock == (common.Address{}) {
+		return errors.New("timelock address must not be zero")
+	}
+	if !target.Role.Valid() {
+		return errors.New("role is unsupported")
+	}
+	if target.Address == (common.Address{}) {
+		return errors.New("address must not be zero")
+	}
+
+	return nil
+}

mcms/evm/grant-role/operation_test.go

@@ -13,16 +13,28 @@ import (
 	"github.com/smartcontractkit/chainlink-deployments-framework/engine/test/runtime"
 	"github.com/smartcontractkit/chainlink-deployments-framework/operations"
 	"github.com/smartcontractkit/chainlink-deployments-framework/pkg/logger"
+	mcmssdk "github.com/smartcontractkit/mcms/sdk"
 	mcmsevmsdk "github.com/smartcontractkit/mcms/sdk/evm"
 
-	"github.com/smartcontractkit/cld-changesets/internal/mcmsrole"
-	evmops "github.com/smartcontractkit/cld-changesets/legacy/mcms/oputils"
 	timelockops "github.com/smartcontractkit/cld-changesets/mcms/evm/deploy/v1_0_0/operations/rbac_timelock"
 	evmgrantrole "github.com/smartcontractkit/cld-changesets/mcms/evm/grant-role"
 )
 
+func TestOpEVMGrantRoleInputGasOverridable(t *testing.T) {
+	t.Parallel()
+
+	in := evmgrantrole.OpEVMGrantRoleInput{GasLimit: 100, GasPrice: 200}
+	gotLimit, gotPrice := in.GasBoostValues()
+	require.Equal(t, uint64(100), gotLimit)
+	require.Equal(t, uint64(200), gotPrice)
+
+	boosted := in.WithGasBoost(500, 600)
+	require.Equal(t, uint64(500), boosted.GasLimit)
+	require.Equal(t, uint64(600), boosted.GasPrice)
+}
+
 // TestOpGrantRole deploys a timelock with the deployer as admin and grants the
-// executor role to a fresh address, asserting it shows up in the inspector.
+// executor role to a fresh address via the MCMS SDK timelock configurer.
 func TestOpGrantRole(t *testing.T) {
 	t.Parallel()
 
@@ -53,16 +65,16 @@ func TestOpGrantRole(t *testing.T) {
 	timelockAddr := common.HexToAddress(tlReport.Output.Address)
 
 	grantee := common.HexToAddress("0x00000000000000000000000000000000000000aa")
-	_, err = operations.ExecuteOperation(bundle, evmgrantrole.OpGrantRole, chain,
-		evmops.EVMCallInput[evmgrantrole.OpGrantRoleInput]{
-			ChainSelector: sel,
-			Address:       timelockAddr,
-			CallInput: evmgrantrole.OpGrantRoleInput{
-				Account: grantee,
-				RoleID:  [32]byte(mcmsrole.ExecutorRole.ID),
+	report, err := operations.ExecuteOperation(bundle, evmgrantrole.OpEVMGrantRole, chain,
+		evmgrantrole.OpEVMGrantRoleInput{
+			Target: evmgrantrole.GrantRoleTarget{
+				Timelock: timelockAddr,
+				Role:     mcmssdk.TimelockRoleExecutor,
+				Address:  grantee,
 			},
 		})
 	require.NoError(t, err)
+	require.True(t, report.Output.Executed())
 
 	executors, err := mcmsevmsdk.NewTimelockInspector(chain.Client).GetExecutors(t.Context(), timelockAddr.Hex())
 	require.NoError(t, err)