Initialization for Crib

deployment/address_book.go

@@ -89,8 +89,10 @@ type AddressBook interface {
 	Remove(ab AddressBook) error
 }
 
+type AddressesByChain map[uint64]map[string]TypeAndVersion
+
 type AddressBookMap struct {
-	addressesByChain map[uint64]map[string]TypeAndVersion
+	addressesByChain AddressesByChain
 	mtx              sync.RWMutex
 }
 

deployment/ccip/changeset/cs_add_chain_test.go

@@ -1,7 +1,6 @@
 package changeset
 
 import (
-	"math/big"
 	"testing"
 	"time"
 
@@ -51,13 +50,9 @@ func TestAddChainInbound(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses))
 
-	cfg := commontypes.MCMSWithTimelockConfig{
-		Canceller:         commonchangeset.SingleGroupMCMS(t),
-		Bypasser:          commonchangeset.SingleGroupMCMS(t),
-		Proposer:          commonchangeset.SingleGroupMCMS(t),
-		TimelockExecutors: e.Env.AllDeployerKeys(),
-		TimelockMinDelay:  big.NewInt(0),
-	}
+	cfg, err := commonchangeset.CreateMCMSConfig(e.Env.AllDeployerKeys())
+	require.NoError(t, err)
+
 	out, err := commonchangeset.DeployMCMSWithTimelock(e.Env, map[uint64]commontypes.MCMSWithTimelockConfig{
 		initialDeploy[0]: cfg,
 		initialDeploy[1]: cfg,
@@ -72,7 +67,7 @@ func TestAddChainInbound(t *testing.T) {
 	for _, chain := range initialDeploy {
 		chainConfig[chain] = DefaultOCRParams(e.FeedChainSel, nil, nil)
 	}
-	err = deployCCIPContracts(e.Env, newAddresses, NewChainsConfig{
+	err = DeployCCIPContracts(e.Env, newAddresses, NewChainsConfig{
 		HomeChainSel:       e.HomeChainSel,
 		FeedChainSel:       e.FeedChainSel,
 		ChainConfigByChain: chainConfig,

deployment/ccip/changeset/cs_deploy_chain.go

@@ -65,7 +65,7 @@ func (c DeployChainContractsConfig) Validate() error {
 	return nil
 }
 
-// deployCCIPContracts assumes the following contracts are deployed:
+// DeployCCIPContracts assumes the following contracts are deployed:
 // - Capability registry
 // - CCIP home
 // - RMN home
@@ -74,7 +74,7 @@ func (c DeployChainContractsConfig) Validate() error {
 // It then deploys the rest of the CCIP chain contracts to the selected chains
 // registers the nodes with the capability registry and creates a DON for
 // each new chain.
-func deployCCIPContracts(
+func DeployCCIPContracts(
 	e deployment.Environment,
 	ab deployment.AddressBook,
 	c NewChainsConfig) error {

deployment/ccip/changeset/cs_deploy_chain_test.go

@@ -3,7 +3,6 @@ package changeset
 import (
 	"encoding/json"
 	"fmt"
-	"math/big"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -51,13 +50,8 @@ func TestDeployChainContractsChangeset(t *testing.T) {
 
 	cfg := make(map[uint64]commontypes.MCMSWithTimelockConfig)
 	for _, chain := range e.AllChainSelectors() {
-		cfg[chain] = commontypes.MCMSWithTimelockConfig{
-			Canceller:         commonchangeset.SingleGroupMCMS(t),
-			Bypasser:          commonchangeset.SingleGroupMCMS(t),
-			Proposer:          commonchangeset.SingleGroupMCMS(t),
-			TimelockExecutors: e.AllDeployerKeys(),
-			TimelockMinDelay:  big.NewInt(0),
-		}
+		cfg[chain], err = commonchangeset.CreateMCMSConfig(e.AllDeployerKeys())
+		require.NoError(t, err)
 	}
 	output, err = commonchangeset.DeployMCMSWithTimelock(e, cfg)
 	require.NoError(t, err)

deployment/ccip/changeset/cs_home_chain.go

@@ -82,9 +82,9 @@ func (c DeployHomeChainConfig) Validate() error {
 	return nil
 }
 
-// deployCapReg deploys the CapabilitiesRegistry contract if it is not already deployed
+// DeployCapReg deploys the CapabilitiesRegistry contract if it is not already deployed
 // and returns a deployment.ContractDeploy struct with the address and contract instance.
-func deployCapReg(
+func DeployCapReg(
 	lggr logger.Logger,
 	state CCIPOnChainState,
 	ab deployment.AddressBook,
@@ -133,7 +133,7 @@ func deployHomeChain(
 		return nil, fmt.Errorf("failed to load onchain state: %w", err)
 	}
 	// Deploy CapabilitiesRegistry, CCIPHome, RMNHome
-	capReg, err := deployCapReg(lggr, state, ab, chain)
+	capReg, err := DeployCapReg(lggr, state, ab, chain)
 	if err != nil {
 		return nil, err
 	}

deployment/ccip/changeset/test_helpers.go

@@ -138,7 +138,7 @@ func DeployTestContracts(t *testing.T,
 	linkPrice *big.Int,
 	wethPrice *big.Int,
 ) deployment.CapabilityRegistryConfig {
-	capReg, err := deployCapReg(lggr,
+	capReg, err := DeployCapReg(lggr,
 		// deploying cap reg for the first time on a blank chain state
 		CCIPOnChainState{
 			Chains: make(map[uint64]CCIPChainState),
@@ -272,13 +272,8 @@ func NewMemoryEnvironmentWithJobsAndContracts(t *testing.T, lggr logger.Logger,
 	allChains := e.Env.AllChainSelectors()
 	mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig)
 	for _, c := range e.Env.AllChainSelectors() {
-		mcmsCfg[c] = commontypes.MCMSWithTimelockConfig{
-			Canceller:         commonchangeset.SingleGroupMCMS(t),
-			Bypasser:          commonchangeset.SingleGroupMCMS(t),
-			Proposer:          commonchangeset.SingleGroupMCMS(t),
-			TimelockExecutors: e.Env.AllDeployerKeys(),
-			TimelockMinDelay:  big.NewInt(0),
-		}
+		mcmsCfg[c], err = commonchangeset.CreateMCMSConfig(e.Env.AllDeployerKeys())
+		require.NoError(t, err)
 	}
 	var usdcChains []uint64
 	if tCfg != nil && tCfg.IsUSDC {

deployment/common/changeset/internal/mcms_test.go

@@ -2,7 +2,6 @@ package internal_test
 
 import (
 	"encoding/json"
-	"math/big"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -23,8 +22,10 @@ func TestDeployMCMSWithConfig(t *testing.T) {
 		chainsel.TEST_90000001.EvmChainID,
 	})
 	ab := deployment.NewMemoryAddressBook()
-	_, err := internal.DeployMCMSWithConfig(types.ProposerManyChainMultisig,
-		lggr, chains[chainsel.TEST_90000001.Selector], ab, changeset.SingleGroupMCMS(t))
+	m, err := changeset.SingleGroupMCMS()
+	require.NoError(t, err)
+	_, err = internal.DeployMCMSWithConfig(types.ProposerManyChainMultisig,
+		lggr, chains[chainsel.TEST_90000001.Selector], ab, m)
 	require.NoError(t, err)
 }
 
@@ -34,17 +35,14 @@ func TestDeployMCMSWithTimelockContracts(t *testing.T) {
 		chainsel.TEST_90000001.EvmChainID,
 	})
 	ab := deployment.NewMemoryAddressBook()
-	_, err := internal.DeployMCMSWithTimelockContracts(lggr,
+	mcmsConfig, err := changeset.CreateMCMSConfig([]common.Address{
+		chains[chainsel.TEST_90000001.Selector].DeployerKey.From,
+	})
+	require.NoError(t, err)
+	_, err = internal.DeployMCMSWithTimelockContracts(lggr,
 		chains[chainsel.TEST_90000001.Selector],
-		ab, types.MCMSWithTimelockConfig{
-			Canceller: changeset.SingleGroupMCMS(t),
-			Bypasser:  changeset.SingleGroupMCMS(t),
-			Proposer:  changeset.SingleGroupMCMS(t),
-			TimelockExecutors: []common.Address{
-				chains[chainsel.TEST_90000001.Selector].DeployerKey.From,
-			},
-			TimelockMinDelay: big.NewInt(0),
-		})
+		ab,
+		mcmsConfig)
 	require.NoError(t, err)
 	addresses, err := ab.AddressesForChain(chainsel.TEST_90000001.Selector)
 	require.NoError(t, err)

deployment/common/changeset/mcms_test_helpers.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"context"
 	"crypto/ecdsa"
+	commontypes "github.com/smartcontractkit/chainlink/deployment/common/types"
+	"math/big"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -33,15 +35,40 @@ func init() {
 	TestXXXMCMSSigner = key
 }
 
-func SingleGroupMCMS(t *testing.T) config.Config {
+func SingleGroupMCMS() (config.Config, error) {
 	publicKey := TestXXXMCMSSigner.Public().(*ecdsa.PublicKey)
 	// Convert the public key to an Ethereum address
 	address := crypto.PubkeyToAddress(*publicKey)
 	c, err := config.NewConfig(1, []common.Address{address}, []config.Config{})
-	require.NoError(t, err)
-	return *c
+
+	if err != nil {
+		return config.Config{}, err
+	}
+	return *c, nil
 }
 
+func CreateMCMSConfig(depKeys []common.Address) (commontypes.MCMSWithTimelockConfig, error) {
+	c, err := SingleGroupMCMS()
+	if err != nil {
+		return commontypes.MCMSWithTimelockConfig{}, err
+	}
+	b, err := SingleGroupMCMS()
+	if err != nil {
+		return commontypes.MCMSWithTimelockConfig{}, err
+	}
+	p, err := SingleGroupMCMS()
+	if err != nil {
+		return commontypes.MCMSWithTimelockConfig{}, err
+	}
+	return commontypes.MCMSWithTimelockConfig{
+		Canceller:         c,
+		Bypasser:          b,
+		Proposer:          p,
+		TimelockExecutors: depKeys,
+		TimelockMinDelay:  big.NewInt(0),
+	}, nil
+
+}
 func SignProposal(t *testing.T, env deployment.Environment, proposal *timelock.MCMSWithTimelockProposal) *mcms.Executor {
 	executorClients := make(map[mcms.ChainIdentifier]mcms.ContractDeployBackend)
 	for _, chain := range env.Chains {

deployment/environment/crib/ccip_deployer.go

@@ -0,0 +1,158 @@
+package crib
+
+import (
+	"context"
+	"errors"
+	chainsel "github.com/smartcontractkit/chain-selectors"
+	jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job"
+	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	commontypes "github.com/smartcontractkit/chainlink/deployment/common/types"
+	"golang.org/x/exp/maps"
+	"math/big"
+
+	"github.com/smartcontractkit/chainlink/deployment/environment/devenv"
+
+	"github.com/smartcontractkit/chainlink/deployment"
+	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
+	"github.com/smartcontractkit/chainlink/v2/core/logger"
+	"github.com/smartcontractkit/chainlink/v2/core/services/relay"
+)
+
+// DeployHomeChainContracts deploys the home chain contracts so that the chainlink nodes can be started with the CR address in Capabilities.ExternalRegistry
+func DeployHomeChainContracts(lggr logger.Logger, envConfig devenv.EnvironmentConfig, homeChainSel uint64) (deployment.CapabilityRegistryConfig, deployment.AddressBook, error) {
+	chains, err := devenv.NewChains(lggr, envConfig.Chains)
+	if err != nil {
+		return deployment.CapabilityRegistryConfig{}, nil, err
+	}
+	ab := deployment.NewMemoryAddressBook()
+	capReg, err := changeset.DeployCapReg(lggr,
+		// deploying cap reg for the first time on a blank chain state
+		changeset.CCIPOnChainState{
+			Chains: make(map[uint64]changeset.CCIPChainState),
+		}, ab, chains[homeChainSel])
+	if err != nil {
+		return deployment.CapabilityRegistryConfig{}, nil, err
+	}
+	evmChainID, err := chainsel.ChainIdFromSelector(homeChainSel)
+	if err != nil {
+		return deployment.CapabilityRegistryConfig{}, nil, err
+	}
+	return deployment.CapabilityRegistryConfig{
+		NetworkType: relay.NetworkEVM,
+		EVMChainID:  evmChainID,
+		Contract:    capReg.Address,
+	}, ab, nil
+}
+
+func DeployCCIPAndAddLanes(lggr logger.Logger, envCfg devenv.EnvironmentConfig, homeChainSel, feedChainSel uint64, ab deployment.AddressBook) (DeployCCIPOutput, error) {
+	ctx := context.Background()
+	e, _, err := devenv.NewEnvironment(func() context.Context { return context.Background() }, lggr, envCfg)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	if e == nil {
+		return DeployCCIPOutput{}, errors.New("environment is nil")
+	}
+
+	_, err = changeset.DeployFeeds(lggr, ab, e.Chains[feedChainSel], big.NewInt(9000000), big.NewInt(9000000))
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+
+	e.ExistingAddresses = ab
+	tenv := changeset.DeployedEnv{
+		Env:          *e,
+		HomeChainSel: homeChainSel,
+		FeedChainSel: feedChainSel,
+	}
+	chains := tenv.Env.AllChainSelectors()
+	out, err := changeset.DeployPrerequisites(tenv.Env, changeset.DeployPrerequisiteConfig{
+		ChainSelectors: chains,
+	})
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	err = tenv.Env.ExistingAddresses.Merge(out.AddressBook)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+
+	state, err := changeset.LoadOnchainState(tenv.Env)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	if state.Chains[tenv.HomeChainSel].LinkToken == nil {
+		return DeployCCIPOutput{}, errors.New("link token not deployed")
+	}
+
+	//  Deploy contracts to new chain
+	cfg, err := commonchangeset.CreateMCMSConfig(tenv.Env.AllDeployerKeys())
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	var mcmsConfigs = make(map[uint64]commontypes.MCMSWithTimelockConfig)
+	for _, chain := range chains {
+		mcmsConfigs[chain] = cfg
+	}
+	out, err = commonchangeset.DeployMCMSWithTimelock(tenv.Env, mcmsConfigs)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	err = tenv.Env.ExistingAddresses.Merge(out.AddressBook)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+
+	chainConfig := make(map[uint64]changeset.CCIPOCRParams)
+	for _, chain := range chains {
+		chainConfig[chain] = changeset.DefaultOCRParams(tenv.FeedChainSel, nil, nil)
+	}
+	err = changeset.DeployCCIPContracts(tenv.Env, tenv.Env.ExistingAddresses, changeset.NewChainsConfig{
+		HomeChainSel:       tenv.HomeChainSel,
+		FeedChainSel:       tenv.FeedChainSel,
+		ChainConfigByChain: chainConfig,
+		OCRSecrets:         deployment.XXXGenerateTestOCRSecrets(),
+	})
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	// Get new state after migration.
+
+	state, err = changeset.LoadOnchainState(tenv.Env)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+
+	out, err = changeset.CCIPCapabilityJobspec(tenv.Env, struct{}{})
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	for nodeID, jobs := range out.JobSpecs {
+		for _, job := range jobs {
+			// Note these auto-accept
+			_, err := tenv.Env.Offchain.ProposeJob(ctx,
+				&jobv1.ProposeJobRequest{
+					NodeId: nodeID,
+					Spec:   job,
+				})
+			if err != nil {
+				return DeployCCIPOutput{}, err
+			}
+		}
+	}
+
+	// Add all lanes
+	err = changeset.AddLanesForAll(tenv.Env, state)
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+
+	addresses, err := ab.Addresses()
+	if err != nil {
+		return DeployCCIPOutput{}, err
+	}
+	return DeployCCIPOutput{
+		AddressBook: *deployment.NewMemoryAddressBookFromMap(addresses),
+		NodeIDs:     maps.Keys(out.JobSpecs),
+	}, err
+}