feat: link transfer mcms changesets

deployment/ccip/changeset/state.go

@@ -292,13 +292,13 @@ func LoadOnchainState(e deployment.Environment) (CCIPOnChainState, error) {
 // LoadChainState Loads all state for a chain into state
 func LoadChainState(chain deployment.Chain, addresses map[string]deployment.TypeAndVersion) (CCIPChainState, error) {
 	var state CCIPChainState
-	mcmsWithTimelock, err := commoncs.MaybeLoadMCMSWithTimelockState(chain, addresses)
+	mcmsWithTimelock, err := commoncs.MaybeLoadMCMSWithTimelockChainState(chain, addresses)
 	if err != nil {
 		return state, err
 	}
 	state.MCMSWithTimelockState = *mcmsWithTimelock
 
-	linkState, err := commoncs.MaybeLoadLinkTokenState(chain, addresses)
+	linkState, err := commoncs.MaybeLoadLinkTokenChainState(chain, addresses)
 	if err != nil {
 		return state, err
 	}

deployment/common/changeset/deploy_link_token.go

@@ -12,7 +12,7 @@ import (
 
 var _ deployment.ChangeSet[[]uint64] = DeployLinkToken
 
-// DeployLinkToken deploys a link token contract to the chain identified by the chainSelector.
+// DeployLinkToken deploys a link token contract to the chain identified by the ChainSelector.
 func DeployLinkToken(e deployment.Environment, chains []uint64) (deployment.ChangesetOutput, error) {
 	for _, chain := range chains {
 		_, ok := e.Chains[chain]

deployment/common/changeset/deploy_link_token_test.go

@@ -27,7 +27,7 @@ func TestDeployLinkToken(t *testing.T) {
 	require.NoError(t, err)
 	addrs, err := e.ExistingAddresses.AddressesForChain(chain1)
 	require.NoError(t, err)
-	state, err := changeset.MaybeLoadLinkTokenState(e.Chains[chain1], addrs)
+	state, err := changeset.MaybeLoadLinkTokenChainState(e.Chains[chain1], addrs)
 	require.NoError(t, err)
 	// View itself already unit tested
 	_, err = state.GenerateLinkView()

deployment/common/changeset/example/add_mint_burners_link.go

@@ -0,0 +1,70 @@
+package example
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/smartcontractkit/chainlink/deployment"
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset"
+)
+
+type AddMintersBurnersLinkConfig struct {
+	ChainSelector uint64
+	Minters       []common.Address
+	Burners       []common.Address
+}
+
+var _ deployment.ChangeSet[*AddMintersBurnersLinkConfig] = AddMintersBurnersLink
+
+// AddMintersBurnersLink grants the minter / burner role to the provided addresses.
+func AddMintersBurnersLink(e deployment.Environment, cfg *AddMintersBurnersLinkConfig) (deployment.ChangesetOutput, error) {
+
+	chain := e.Chains[cfg.ChainSelector]
+	addresses, err := e.ExistingAddresses.AddressesForChain(cfg.ChainSelector)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+	linkState, err := changeset.MaybeLoadLinkTokenChainState(chain, addresses)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+
+	for _, minter := range cfg.Minters {
+		// check if minter is already a minter
+		isMinter, err := linkState.LinkToken.IsMinter(&bind.CallOpts{Context: e.GetContext()}, minter)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		if isMinter {
+			continue
+		}
+		tx, err := linkState.LinkToken.GrantMintRole(chain.DeployerKey, minter)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		_, err = deployment.ConfirmIfNoError(chain, tx, err)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+	}
+	for _, burner := range cfg.Burners {
+		// check if burner is already a burner
+		isMinter, err := linkState.LinkToken.IsBurner(&bind.CallOpts{Context: e.GetContext()}, burner)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		if isMinter {
+			continue
+		}
+		tx, err := linkState.LinkToken.GrantBurnRole(chain.DeployerKey, burner)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		_, err = deployment.ConfirmIfNoError(chain, tx, err)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+	}
+	return deployment.ChangesetOutput{}, nil
+
+}

deployment/common/changeset/example/add_mint_burners_link_test.go

@@ -0,0 +1,79 @@
+package example_test
+
+import (
+	"context"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zapcore"
+
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset/example"
+	"github.com/smartcontractkit/chainlink/v2/core/logger"
+
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	"github.com/smartcontractkit/chainlink/deployment/common/types"
+	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+)
+
+// TestAddMintersBurnersLink tests the AddMintersBurnersLink changeset
+func TestAddMintersBurnersLink(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	lggr := logger.TestLogger(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 Link 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,
+			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, 6)
+
+	mcmsState, err := changeset.MaybeLoadMCMSWithTimelockChainState(chain, addrs)
+	require.NoError(t, err)
+	linkState, err := changeset.MaybeLoadLinkTokenChainState(chain, addrs)
+	require.NoError(t, err)
+
+	timelockAddress := mcmsState.Timelock.Address()
+
+	// Mint some funds
+	_, err = example.AddMintersBurnersLink(env, &example.AddMintersBurnersLinkConfig{
+		ChainSelector: chainSelector,
+		Minters:       []common.Address{timelockAddress},
+		Burners:       []common.Address{timelockAddress},
+	})
+	require.NoError(t, err)
+
+	// check timelock balance
+	isMinter, err := linkState.LinkToken.IsMinter(&bind.CallOpts{Context: ctx}, timelockAddress)
+	require.NoError(t, err)
+	require.True(t, isMinter)
+	isBurner, err := linkState.LinkToken.IsBurner(&bind.CallOpts{Context: ctx}, timelockAddress)
+	require.NoError(t, err)
+	require.True(t, isBurner)
+}