feat: link transfer mcms changesets

deployment/common/changeset/link_transfer_timelock.go

@@ -0,0 +1,102 @@
+package changeset
+
+import (
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/mcms"
+	"github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock"
+
+	"github.com/smartcontractkit/chainlink/deployment"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/link_token"
+)
+
+type LinkTransfer struct {
+	To    common.Address
+	Value *big.Int
+}
+type LinkTransferTimelockRequest struct {
+	Transfers       map[uint64][]LinkTransfer
+	ValidUntil      uint32        // unix time until the proposal will be valid
+	MinDelay        time.Duration // delay for timelock worker to execute the transfers.
+	OverrideRoot    bool
+	StartingOpCount map[uint64]uint64
+}
+
+var _ deployment.ChangeSet[*LinkTransferTimelockRequest] = LinkTransferTimelock
+
+// LinkTransferTimelock takes the given link transfers and creates an MCMS proposal for them.
+func LinkTransferTimelock(e deployment.Environment, req *LinkTransferTimelockRequest) (deployment.ChangesetOutput, error) {
+	chainMetadata := map[mcms.ChainIdentifier]mcms.ChainMetadata{}
+	timelockAddresses := map[mcms.ChainIdentifier]common.Address{}
+	allBatches := []timelock.BatchChainOperation{}
+	for chainSelector := range req.Transfers {
+		chainID := mcms.ChainIdentifier(chainSelector)
+		chain := e.Chains[chainSelector]
+		addrs, err := e.ExistingAddresses.AddressesForChain(chainSelector)
+		linkState, err := LoadLinkTokenState(chain, addrs)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		linkAddress := linkState.LinkToken.Address()
+		mcmsState, err := LoadMCMSWithTimelockState(chain, addrs)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		mcmAddress := mcmsState.ProposerMcm.Address()
+		timelockAddress := mcmsState.Timelock.Address()
+
+		linkContract, err := link_token.NewLinkToken(linkAddress, chain.Client)
+		if err != nil {
+			return deployment.ChangesetOutput{}, fmt.Errorf("failed to get link contract: %w", err)
+		}
+		chainMetadata[chainID] = mcms.ChainMetadata{
+			MCMAddress:      mcmAddress,
+			StartingOpCount: req.StartingOpCount[chainSelector],
+		}
+		timelockAddresses[chainID] = timelockAddress
+		batch := timelock.BatchChainOperation{
+			ChainIdentifier: chainID,
+			Batch:           []mcms.Operation{},
+		}
+
+		for _, transfer := range req.Transfers[chainSelector] {
+			tx, err := linkContract.Transfer(deployment.SimTransactOpts(), transfer.To, transfer.Value)
+			if err != nil {
+				return deployment.ChangesetOutput{}, fmt.Errorf("error packing transfer tx data: %w", err)
+			}
+			op := mcms.Operation{
+				To:           linkAddress,
+				Data:         tx.Data(),
+				Value:        big.NewInt(0),
+				ContractType: "LinkToken",
+			}
+			batch.Batch = append(batch.Batch, op)
+
+		}
+		allBatches = append(allBatches, batch)
+	}
+
+	proposal, err := timelock.NewMCMSWithTimelockProposal(
+		"1",
+		req.ValidUntil,
+		[]mcms.Signature{},
+		req.OverrideRoot,
+		chainMetadata,
+		timelockAddresses,
+		"Value transfer proposal",
+		allBatches,
+		timelock.Schedule,
+		req.MinDelay.String(),
+	)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+	return deployment.ChangesetOutput{
+		Proposals: []timelock.MCMSWithTimelockProposal{*proposal},
+	}, nil
+
+}

deployment/common/changeset/link_transfer_timelock_test.go

@@ -0,0 +1,124 @@
+package changeset_test
+
+import (
+	"context"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zapcore"
+
+	"github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
+
+	"github.com/smartcontractkit/chainlink/deployment"
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	"github.com/smartcontractkit/chainlink/deployment/common/types"
+	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/link_token"
+)
+
+// TestLinkTransferTimelock tests the LinkTransferTimelock changeset by
+func TestLinkTransferTimelock(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	cfg := memory.MemoryEnvironmentConfig{
+		Nodes:  1,
+		Chains: 2,
+	}
+	env := memory.NewMemoryEnvironment(t, lggr, zapcore.DebugLevel, cfg)
+	chainSelector := env.AllChainSelectors()[0]
+	chain := env.Chains[chainSelector]
+	// Deploy Value Token
+	resp, err := changeset.DeployLinkToken(env, []uint64{chainSelector})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.NoError(t, env.ExistingAddresses.Merge(resp.AddressBook))
+
+	// Deploy MCMS and Timelock
+	config := changeset.SingleGroupMCMS(t)
+	respTimelock, err := changeset.DeployMCMSWithTimelock(env, map[uint64]types.MCMSWithTimelockConfig{
+		chainSelector: {
+			Canceller:         config,
+			Bypasser:          config,
+			Proposer:          config,
+			TimelockExecutors: []common.Address{chain.DeployerKey.From},
+			TimelockMinDelay:  big.NewInt(0),
+		},
+	})
+	require.NoError(t, env.ExistingAddresses.Merge(respTimelock.AddressBook))
+	require.NoError(t, err)
+
+	addrs, err := env.ExistingAddresses.AddressesForChain(chainSelector)
+	require.NoError(t, err)
+	require.Len(t, addrs, 5)
+
+	mcmsState, err := changeset.LoadMCMSWithTimelockState(chain, addrs)
+	require.NoError(t, err)
+	linkState, err := changeset.LoadLinkTokenState(chain, addrs)
+	require.NoError(t, err)
+	linkAddress := linkState.LinkToken.Address()
+	timelockAddress := mcmsState.Timelock.Address()
+
+	linkContract, err := link_token.NewLinkToken(linkAddress, chain.Client)
+	require.NoError(t, err)
+
+	// Mint some funds
+	// grant minter permissions
+	tx, err := linkContract.GrantMintRole(chain.DeployerKey, chain.DeployerKey.From)
+	require.NoError(t, err)
+	_, err = deployment.ConfirmIfNoError(chain, tx, err)
+	require.NoError(t, err)
+
+	tx, err = linkContract.Mint(chain.DeployerKey, timelockAddress, big.NewInt(750))
+	require.NoError(t, err)
+	_, err = deployment.ConfirmIfNoError(chain, tx, err)
+	require.NoError(t, err)
+
+	timelockContract, err := gethwrappers.NewRBACTimelock(timelockAddress, chain.Client)
+	require.NoError(t, err)
+	timelocks := map[uint64]*gethwrappers.RBACTimelock{
+		chainSelector: timelockContract,
+	}
+
+	// Apply the changeset
+	_, err = changeset.ApplyChangesets(t, env, timelocks, []changeset.ChangesetApplication{
+		// the changeset produces proposals, ApplyChangesets will sign & execute them.
+		// in practice, signing and executing are separated processes.
+		{
+			Changeset: changeset.WrapChangeSet(changeset.LinkTransferTimelock),
+			Config: &changeset.LinkTransferTimelockRequest{
+				Transfers: map[uint64][]changeset.LinkTransfer{
+					chainSelector: {
+						{
+							To:    chain.DeployerKey.From,
+							Value: big.NewInt(500),
+						},
+					},
+				},
+				ValidUntil:   4131638958,
+				MinDelay:     0,
+				OverrideRoot: true,
+				StartingOpCount: map[uint64]uint64{
+					chainSelector: 0,
+				},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	// Check new balances
+	endBalance, err := linkContract.BalanceOf(&bind.CallOpts{Context: ctx}, chain.DeployerKey.From)
+	require.NoError(t, err)
+	expectedBalance := big.NewInt(500)
+	require.Equal(t, expectedBalance, endBalance)
+
+	// check timelock balance
+	endBalance, err = linkContract.BalanceOf(&bind.CallOpts{Context: ctx}, timelockAddress)
+	require.NoError(t, err)
+	expectedBalance = big.NewInt(250)
+	require.Equal(t, expectedBalance, endBalance)
+}

deployment/environment.go

@@ -156,7 +156,7 @@ func MaybeDataErr(err error) error {
 	var d rpc.DataError
 	ok := errors.As(err, &d)
 	if ok {
-		return d
+		return fmt.Errorf("%s: %v", d.Error(), d.ErrorData())
 	}
 	return err
 }