Add more test for deployer group

deployment/ccip/changeset/deployer_group.go

@@ -3,6 +3,7 @@ package changeset
 import (
 	"context"
 	"fmt"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -47,6 +48,19 @@ func (d *DeployerGroup) getDeployer(chain uint64) *bind.TransactOpts {
 	txOpts := d.e.Chains[chain].DeployerKey
 	if d.mcmConfig != nil {
 		txOpts = deployment.SimTransactOpts()
+		txOpts = &bind.TransactOpts{
+			From:       d.state.Chains[chain].Timelock.Address(),
+			Signer:     txOpts.Signer,
+			GasLimit:   txOpts.GasLimit,
+			GasPrice:   txOpts.GasPrice,
+			Nonce:      txOpts.Nonce,
+			Value:      txOpts.Value,
+			GasFeeCap:  txOpts.GasFeeCap,
+			GasTipCap:  txOpts.GasTipCap,
+			Context:    txOpts.Context,
+			AccessList: txOpts.AccessList,
+			NoSend:     txOpts.NoSend,
+		}
 	}
 	sim := &bind.TransactOpts{
 		From:       txOpts.From,
@@ -62,7 +76,22 @@ func (d *DeployerGroup) getDeployer(chain uint64) *bind.TransactOpts {
 		NoSend:     true,
 	}
 	oldSigner := sim.Signer
+
+	var startingNonce *big.Int
+	if txOpts.Nonce != nil {
+		startingNonce = new(big.Int).Set(txOpts.Nonce)
+	} else {
+		nonce, err := d.e.Chains[chain].Client.PendingNonceAt(context.Background(), txOpts.From)
+		if err != nil {
+			panic(fmt.Errorf("could not get nonce for deployer: %v", err))
+		}
+		startingNonce = new(big.Int).SetUint64(nonce)
+	}
+
 	sim.Signer = func(a common.Address, t *types.Transaction) (*types.Transaction, error) {
+		// Update the nonce to consider the transactions that have been sent
+		sim.Nonce = big.NewInt(0).Add(startingNonce, big.NewInt(int64(len(d.transactions[chain]))+1))
+
 		tx, err := oldSigner(a, t)
 		if err != nil {
 			return nil, err

deployment/ccip/changeset/deployer_group_test.go

@@ -0,0 +1,184 @@
+package changeset
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/smartcontractkit/chainlink/deployment"
+	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	"github.com/stretchr/testify/require"
+)
+
+type dummyDeployerGroupChangesetConfig struct {
+	selector uint64
+	address  common.Address
+	mints    []*big.Int
+	MCMS     *MCMSConfig
+}
+
+func dummyDeployerGroupGrantMintChangeset(e deployment.Environment, cfg dummyDeployerGroupChangesetConfig) (deployment.ChangesetOutput, error) {
+	state, err := LoadOnchainState(e)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+
+	token := state.Chains[cfg.selector].LinkToken
+
+	group := NewDeployerGroup(e, state, cfg.MCMS)
+	deployer := group.getDeployer(cfg.selector)
+
+	_, err = token.GrantMintRole(deployer, deployer.From)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+
+	return group.enact("Grant mint role")
+}
+
+func dummyDeployerGroupMintChangeset(e deployment.Environment, cfg dummyDeployerGroupChangesetConfig) (deployment.ChangesetOutput, error) {
+	state, err := LoadOnchainState(e)
+	if err != nil {
+		return deployment.ChangesetOutput{}, err
+	}
+
+	token := state.Chains[cfg.selector].LinkToken
+
+	group := NewDeployerGroup(e, state, cfg.MCMS)
+	deployer := group.getDeployer(cfg.selector)
+
+	for _, mint := range cfg.mints {
+		_, err = token.Mint(deployer, cfg.address, mint)
+		if err != nil {
+			return deployment.ChangesetOutput{}, err
+		}
+	}
+
+	return group.enact("Mint tokens")
+}
+
+type deployerGroupTestCase struct {
+	name        string
+	cfg         dummyDeployerGroupChangesetConfig
+	expectError bool
+}
+
+var deployerGroupTestCases = []deployerGroupTestCase{
+	{
+		name: "happy path",
+		cfg: dummyDeployerGroupChangesetConfig{
+			mints:   []*big.Int{big.NewInt(1), big.NewInt(2)},
+			address: common.HexToAddress("0x455E5AA18469bC6ccEF49594645666C587A3a71B"),
+		},
+	},
+	{
+		name: "error",
+		cfg: dummyDeployerGroupChangesetConfig{
+			mints:   []*big.Int{big.NewInt(-1)},
+			address: common.HexToAddress("0x455E5AA18469bC6ccEF49594645666C587A3a71B"),
+		},
+		expectError: true,
+	},
+}
+
+func TestDeployerGroup(t *testing.T) {
+	for _, tc := range deployerGroupTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			e, _ := NewMemoryEnvironment(t, WithChains(2))
+
+			tc.cfg.selector = e.HomeChainSel
+			tc.cfg.MCMS = nil
+
+			_, err := dummyDeployerGroupGrantMintChangeset(e.Env, tc.cfg)
+			require.NoError(t, err)
+
+			_, err = dummyDeployerGroupMintChangeset(e.Env, tc.cfg)
+			if tc.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				state, err := LoadOnchainState(e.Env)
+				require.NoError(t, err)
+
+				token := state.Chains[e.HomeChainSel].LinkToken
+
+				amount, err := token.BalanceOf(nil, tc.cfg.address)
+				require.NoError(t, err)
+
+				sumOfMints := big.NewInt(0)
+				for _, mint := range tc.cfg.mints {
+					sumOfMints = sumOfMints.Add(sumOfMints, mint)
+				}
+
+				require.Equal(t, sumOfMints, amount)
+			}
+		})
+	}
+}
+
+func TestDeployerGroupMCMS(t *testing.T) {
+	for _, tc := range deployerGroupTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.expectError {
+				t.Skip("skipping test because it's not possible to verify error when using MCMS since we are explicitly failing the test in ApplyChangesets")
+			}
+
+			e, _ := NewMemoryEnvironment(t, WithChains(2))
+
+			tc.cfg.selector = e.HomeChainSel
+			tc.cfg.MCMS = &MCMSConfig{
+				MinDelay: 0,
+			}
+			state, err := LoadOnchainState(e.Env)
+			require.NoError(t, err)
+
+			timelocksPerChain := buildTimelockPerChain(e.Env, state)
+
+			contractsByChain := make(map[uint64][]common.Address)
+			contractsByChain[e.HomeChainSel] = []common.Address{state.Chains[e.HomeChainSel].LinkToken.Address()}
+
+			_, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{
+				{
+					Changeset: commonchangeset.WrapChangeSet(commonchangeset.TransferToMCMSWithTimelock),
+					Config: commonchangeset.TransferToMCMSWithTimelockConfig{
+						ContractsByChain: contractsByChain,
+						MinDelay:         0,
+					},
+				},
+			})
+			require.NoError(t, err)
+
+			_, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{
+				{
+					Changeset: commonchangeset.WrapChangeSet(dummyDeployerGroupGrantMintChangeset),
+					Config:    tc.cfg,
+				},
+			})
+			require.NoError(t, err)
+
+			_, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{
+				{
+					Changeset: commonchangeset.WrapChangeSet(dummyDeployerGroupMintChangeset),
+					Config:    tc.cfg,
+				},
+			})
+			require.NoError(t, err)
+
+			state, err = LoadOnchainState(e.Env)
+			require.NoError(t, err)
+
+			token := state.Chains[e.HomeChainSel].LinkToken
+
+			amount, err := token.BalanceOf(nil, tc.cfg.address)
+			require.NoError(t, err)
+
+			sumOfMints := big.NewInt(0)
+			for _, mint := range tc.cfg.mints {
+				sumOfMints = sumOfMints.Add(sumOfMints, mint)
+			}
+
+			require.Equal(t, sumOfMints, amount)
+		})
+	}
+}