feat: link transfer mcms changesets

deployment/ccip/changeset/state.go

@@ -301,13 +301,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
+		isBurner, err := linkState.LinkToken.IsBurner(&bind.CallOpts{Context: e.GetContext()}, burner)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+		if isBurner {
+			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,50 @@
+package example_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	"github.com/smartcontractkit/chainlink/deployment/common/changeset/example"
+)
+
+// TestAddMintersBurnersLink tests the AddMintersBurnersLink changeset
+func TestAddMintersBurnersLink(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	// Deploy Link Token and Timelock contracts and add addresses to environment
+	env := setupLinkTransferTestEnv(t)
+
+	chainSelector := env.AllChainSelectors()[0]
+	chain := env.Chains[chainSelector]
+	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)
+}