Ccip-4308 Test logic optimizations for docker node tests

.github/e2e-tests.yml

@@ -935,14 +935,27 @@ runner-test-matrix:
 
   # START: CCIPv1.6 tests
 
-  - id: smoke/ccip/ccip_test.go:*
+  - id: smoke/ccip/ccip_test.go:^TestInitialDeployOnLocal$
     path: integration-tests/smoke/ccip/ccip_test.go
     test_env_type: docker
     runs_on: ubuntu-latest
     triggers:
       - PR E2E Core Tests
       - Nightly E2E Tests
-    test_cmd: cd integration-tests/smoke/ccip && go test ccip_test.go -timeout 12m -test.parallel=2 -count=1 -json
+    test_cmd: cd integration-tests/smoke/ccip && go test -test.run ^TestInitialDeployOnLocal$ -timeout 12m -test.parallel=2 -count=1 -json
+    pyroscope_env: ci-smoke-ccipv1_6-evm-simulated
+    test_env_vars:
+      E2E_TEST_SELECTED_NETWORK: SIMULATED_1,SIMULATED_2
+      E2E_JD_VERSION: 0.6.0
+
+  - id: smoke/ccip/ccip_test.go:^TestTokenTransfer$
+    path: integration-tests/smoke/ccip/ccip_test.go
+    test_env_type: docker
+    runs_on: ubuntu-latest
+    triggers:
+      - PR E2E Core Tests
+      - Nightly E2E Tests
+    test_cmd: cd integration-tests/smoke/ccip && go test -test.run ^TestTokenTransfer$ -timeout 12m -test.parallel=2 -count=1 -json
     pyroscope_env: ci-smoke-ccipv1_6-evm-simulated
     test_env_vars:
       E2E_TEST_SELECTED_NETWORK: SIMULATED_1,SIMULATED_2
@@ -981,7 +994,7 @@ runner-test-matrix:
     triggers:
       - PR E2E Core Tests
       - Nightly E2E Tests
-    test_cmd: cd integration-tests/smoke/ccip && go test ccip_usdc_test.go -timeout 18m -test.parallel=1 -count=1 -json
+    test_cmd: cd integration-tests/smoke/ccip && go test ccip_usdc_test.go -timeout 18m -test.parallel=5 -count=1 -json
     pyroscope_env: ci-smoke-ccipv1_6-evm-simulated
     test_env_vars:
       E2E_TEST_SELECTED_NETWORK: SIMULATED_1,SIMULATED_2,SIMULATED_3

deployment/ccip/changeset/deploy.go

@@ -315,7 +315,9 @@ func deployPrerequisiteContracts(e deployment.Environment, ab deployment.Address
 		}
 		e.Logger.Infow("deployed ccip multicall", "addr", multicall3Contract.Address)
 	} else {
-		e.Logger.Info("ccip multicall already deployed", "addr", mc3.Address)
+		if mc3 != nil {
+			e.Logger.Info("ccip multicall already deployed", "addr", mc3.Address)
+		}
 	}
 	if isUSDC {
 		token, pool, messenger, transmitter, err1 := DeployUSDC(e.Logger, chain, ab, rmnProxy.Address(), r.Address())

deployment/ccip/changeset/deploy_home_chain.go

@@ -18,8 +18,9 @@ import (
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 
-	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal"
+
+	"github.com/smartcontractkit/chainlink/deployment"
 	cctypes "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/ccip_home"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp"
@@ -478,7 +479,7 @@ func addDON(
 	if _, err := deployment.ConfirmIfNoError(dest, tx, err); err != nil {
 		return err
 	}
-
+	lggr.Infow("Set OCR3 Configs", "chainSelector", dest.Selector)
 	mapOfframpOCR3Configs := make(map[cctypes.PluginType]offramp.MultiOCR3BaseOCRConfigArgs)
 	for _, config := range offrampOCR3Configs {
 		mapOfframpOCR3Configs[cctypes.PluginType(config.OcrPluginType)] = config

deployment/ccip/changeset/test_helpers.go

@@ -17,6 +17,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
 	"github.com/smartcontractkit/chainlink-ccip/pluginconfig"
+	"golang.org/x/sync/errgroup"
 
 	commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config"
 
@@ -84,10 +85,11 @@ func Context(tb testing.TB) context.Context {
 }
 
 type DeployedEnv struct {
-	Env          deployment.Environment
-	HomeChainSel uint64
-	FeedChainSel uint64
-	ReplayBlocks map[uint64]uint64
+	Env            deployment.Environment
+	HomeChainSel   uint64
+	FeedChainSel   uint64
+	ReplayBlocks   map[uint64]uint64
+	SenderAccounts map[uint64]*bind.TransactOpts
 }
 
 func (e *DeployedEnv) SetupJobs(t *testing.T) {
@@ -708,40 +710,65 @@ func DeployTransferableToken(
 	addresses deployment.AddressBook,
 	token string,
 ) (*burn_mint_erc677.BurnMintERC677, *burn_mint_token_pool.BurnMintTokenPool, *burn_mint_erc677.BurnMintERC677, *burn_mint_token_pool.BurnMintTokenPool, error) {
+	deployGrp := errgroup.Group{}
 	// Deploy token and pools
-	srcToken, srcPool, err := deployTransferTokenOneEnd(lggr, chains[src], addresses, token)
-	if err != nil {
-		return nil, nil, nil, nil, err
-	}
-	dstToken, dstPool, err := deployTransferTokenOneEnd(lggr, chains[dst], addresses, token)
-	if err != nil {
-		return nil, nil, nil, nil, err
-	}
-
-	// Attach token pools to registry
-	if err := attachTokenToTheRegistry(chains[src], state.Chains[src], chains[src].DeployerKey, srcToken.Address(), srcPool.Address()); err != nil {
-		return nil, nil, nil, nil, err
-	}
-
-	if err := attachTokenToTheRegistry(chains[dst], state.Chains[dst], chains[dst].DeployerKey, dstToken.Address(), dstPool.Address()); err != nil {
-		return nil, nil, nil, nil, err
-	}
-
-	// Connect pool to each other
-	if err := setTokenPoolCounterPart(chains[src], srcPool, dst, dstToken.Address(), dstPool.Address()); err != nil {
-		return nil, nil, nil, nil, err
-	}
+	var srcToken *burn_mint_erc677.BurnMintERC677
+	var srcPool *burn_mint_token_pool.BurnMintTokenPool
+	var dstToken *burn_mint_erc677.BurnMintERC677
+	var dstPool *burn_mint_token_pool.BurnMintTokenPool
+	deployGrp.Go(func() error {
+		var err error
+		srcToken, srcPool, err = deployTransferTokenOneEnd(lggr, chains[src], addresses, token)
+		if err != nil {
+			return err
+		}
+		// Attach token pools to registry
+		if err := attachTokenToTheRegistry(chains[src], state.Chains[src], chains[src].DeployerKey, srcToken.Address(), srcPool.Address()); err != nil {
+			return err
+		}
+		return nil
+	})
+	deployGrp.Go(func() error {
+		var err error
+		dstToken, dstPool, err = deployTransferTokenOneEnd(lggr, chains[dst], addresses, token)
+		if err != nil {
+			return err
+		}
 
-	if err := setTokenPoolCounterPart(chains[dst], dstPool, src, srcToken.Address(), srcPool.Address()); err != nil {
+		if err := attachTokenToTheRegistry(chains[dst], state.Chains[dst], chains[dst].DeployerKey, dstToken.Address(), dstPool.Address()); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err := deployGrp.Wait(); err != nil {
 		return nil, nil, nil, nil, err
 	}
-
-	// Add burn/mint permissions
-	if err := grantMintBurnPermissions(lggr, chains[src], srcToken, srcPool.Address()); err != nil {
-		return nil, nil, nil, nil, err
+	if srcToken == nil || srcPool == nil || dstToken == nil || dstPool == nil {
+		return nil, nil, nil, nil, fmt.Errorf("failed to deploy token and pool")
 	}
-
-	if err := grantMintBurnPermissions(lggr, chains[dst], dstToken, dstPool.Address()); err != nil {
+	configurePoolGrp := errgroup.Group{}
+	configurePoolGrp.Go(func() error {
+		err := setTokenPoolCounterPart(chains[src], srcPool, dst, dstToken.Address(), dstPool.Address())
+		if err != nil {
+			return fmt.Errorf("failed to set token pool counter part chain %d: %w", src, err)
+		}
+		err = grantMintBurnPermissions(lggr, chains[src], srcToken, srcPool.Address())
+		if err != nil {
+			return fmt.Errorf("failed to grant mint burn permissions chain %d: %w", src, err)
+		}
+		return nil
+	})
+	configurePoolGrp.Go(func() error {
+		err := setTokenPoolCounterPart(chains[dst], dstPool, src, srcToken.Address(), srcPool.Address())
+		if err != nil {
+			return fmt.Errorf("failed to set token pool counter part chain %d: %w", dst, err)
+		}
+		if err := grantMintBurnPermissions(lggr, chains[dst], dstToken, dstPool.Address()); err != nil {
+			return fmt.Errorf("failed to grant mint burn permissions chain %d: %w", dst, err)
+		}
+		return nil
+	})
+	if err := configurePoolGrp.Wait(); err != nil {
 		return nil, nil, nil, nil, err
 	}
 

deployment/ccip/changeset/test_usdc_helpers.go

@@ -1,9 +1,11 @@
 package changeset
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/smartcontractkit/chainlink-ccip/pkg/reader"
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
@@ -26,53 +28,53 @@ func ConfigureUSDCTokenPools(
 	dstToken := state.Chains[dst].BurnMintTokens677[USDCSymbol]
 	srcPool := state.Chains[src].USDCTokenPool
 	dstPool := state.Chains[dst].USDCTokenPool
-
-	// Attach token pools to registry
-	if err := attachTokenToTheRegistry(chains[src], state.Chains[src], chains[src].DeployerKey, srcToken.Address(), srcPool.Address()); err != nil {
-		lggr.Errorw("Failed to attach token to the registry", "err", err, "token", srcToken.Address(), "pool", srcPool.Address())
-		return nil, nil, err
-	}
-
-	if err := attachTokenToTheRegistry(chains[dst], state.Chains[dst], chains[dst].DeployerKey, dstToken.Address(), dstPool.Address()); err != nil {
-		lggr.Errorw("Failed to attach token to the registry", "err", err, "token", dstToken.Address(), "pool", dstPool.Address())
-		return nil, nil, err
-	}
-
-	// Connect pool to each other
-	if err := setUSDCTokenPoolCounterPart(chains[src], srcPool, dst, dstToken.Address(), dstPool.Address()); err != nil {
-		lggr.Errorw("Failed to set counter part", "err", err, "srcPool", srcPool.Address(), "dstPool", dstPool.Address())
-		return nil, nil, err
-	}
-
-	if err := setUSDCTokenPoolCounterPart(chains[dst], dstPool, src, srcToken.Address(), srcPool.Address()); err != nil {
-		lggr.Errorw("Failed to set counter part", "err", err, "srcPool", dstPool.Address(), "dstPool", srcPool.Address())
-		return nil, nil, err
-	}
-
-	// Add burn/mint permissions for source
-	for _, addr := range []common.Address{
-		srcPool.Address(),
-		state.Chains[src].MockUSDCTokenMessenger.Address(),
-		state.Chains[src].MockUSDCTransmitter.Address(),
-	} {
-		if err := grantMintBurnPermissions(lggr, chains[src], srcToken, addr); err != nil {
-			lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", srcToken.Address(), "minter", addr)
-			return nil, nil, err
+	configureGrp := errgroup.Group{}
+	configureGrp.Go(func() error {
+		if err := attachTokenToTheRegistry(chains[src], state.Chains[src], chains[src].DeployerKey, srcToken.Address(), srcPool.Address()); err != nil {
+			lggr.Errorw("Failed to attach token to the registry", "chain", src, "err", err, "token", srcToken.Address(), "pool", srcPool.Address())
+			return err
 		}
-	}
-
-	// Add burn/mint permissions for dest
-	for _, addr := range []common.Address{
-		dstPool.Address(),
-		state.Chains[dst].MockUSDCTokenMessenger.Address(),
-		state.Chains[dst].MockUSDCTransmitter.Address(),
-	} {
-		if err := grantMintBurnPermissions(lggr, chains[dst], dstToken, addr); err != nil {
-			lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", dstToken.Address(), "minter", addr)
-			return nil, nil, err
+		// Connect pool to each other
+		if err := setUSDCTokenPoolCounterPart(chains[src], srcPool, dst, dstToken.Address(), dstPool.Address()); err != nil {
+			lggr.Errorw("Failed to set counter part", "err", err, "srcPool", srcPool.Address(), "dstPool", dstPool.Address())
+			return err
+		}
+		for _, addr := range []common.Address{
+			srcPool.Address(),
+			state.Chains[src].MockUSDCTokenMessenger.Address(),
+			state.Chains[src].MockUSDCTransmitter.Address(),
+		} {
+			if err := grantMintBurnPermissions(lggr, chains[src], srcToken, addr); err != nil {
+				lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", srcToken.Address(), "minter", addr)
+				return err
+			}
+		}
+		return nil
+	})
+	configureGrp.Go(func() error {
+		if err := attachTokenToTheRegistry(chains[dst], state.Chains[dst], chains[dst].DeployerKey, dstToken.Address(), dstPool.Address()); err != nil {
+			lggr.Errorw("Failed to attach token to the registry", "chain", dst, "err", err, "token", dstToken.Address(), "pool", dstPool.Address())
+			return err
 		}
+		if err := setUSDCTokenPoolCounterPart(chains[dst], dstPool, src, srcToken.Address(), srcPool.Address()); err != nil {
+			lggr.Errorw("Failed to set counter part", "err", err, "srcPool", dstPool.Address(), "dstPool", srcPool.Address())
+			return err
+		}
+		for _, addr := range []common.Address{
+			dstPool.Address(),
+			state.Chains[dst].MockUSDCTokenMessenger.Address(),
+			state.Chains[dst].MockUSDCTransmitter.Address(),
+		} {
+			if err := grantMintBurnPermissions(lggr, chains[dst], dstToken, addr); err != nil {
+				lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", dstToken.Address(), "minter", addr)
+				return err
+			}
+		}
+		return nil
+	})
+	if err := configureGrp.Wait(); err != nil {
+		return nil, nil, fmt.Errorf("failed to configure USDC token pools: %w", err)
 	}
-
 	return srcToken, dstToken, nil
 }
 

deployment/common/changeset/internal/mcms.go

@@ -4,8 +4,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/ccip-owner-contracts/pkg/config"
 	owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/common/types"
 	"github.com/smartcontractkit/chainlink/deployment/common/view/v1_0"
@@ -62,13 +64,19 @@ func DeployMCMSWithTimelockContractsBatch(
 	ab deployment.AddressBook,
 	cfgByChain map[uint64]types.MCMSWithTimelockConfig,
 ) error {
+	deployGrp := errgroup.Group{}
 	for chainSel, cfg := range cfgByChain {
-		_, err := DeployMCMSWithTimelockContracts(lggr, chains[chainSel], ab, cfg)
-		if err != nil {
-			return err
-		}
+		cfg := cfg
+		chainSel := chainSel
+		deployGrp.Go(func() error {
+			_, err := DeployMCMSWithTimelockContracts(lggr, chains[chainSel], ab, cfg)
+			if err != nil {
+				return err
+			}
+			return nil
+		})
 	}
-	return nil
+	return deployGrp.Wait()
 }
 
 // DeployMCMSWithTimelockContracts deploys an MCMS for
@@ -126,6 +134,7 @@ func DeployMCMSWithTimelockContracts(
 		lggr.Errorw("Failed to grant timelock admin role", "err", err)
 		return nil, err
 	}
+	lggr.Infow("granted timelock admin role", "addr", timelock.Address)
 	// After the proposer cycle is validated,
 	// we can remove the deployer as an admin.
 	return &MCMSWithTimelockDeploy{