Make config import available for only existing chains during deployment (#1889)

* remove unsupported method

* making import config available for only existing chains

* register laneversion resolver

* add supported chain method

* fixing test

Author: AnieeG

ccv/chains/evm/deployment/v1_7_0/adapters/init.go

@@ -34,6 +34,7 @@ func init() {
 	ccvadapters.GetVerifierJobConfigRegistry().Register(chainsel.FamilyEVM, &EVMVerifierJobConfigAdapter{})
 	ccvadapters.GetDeployChainContractsRegistry().Register(chainsel.FamilyEVM, &EVMDeployChainContractsAdapter{})
 	ccvadapters.GetDeployChainContractsRegistry().RegisterConfigImporter(chainsel.FamilyEVM, semver.MustParse("1.6.0"), &adapters1_6.ConfigImportAdapter{})
+	ccvadapters.GetDeployChainContractsRegistry().RegisterLaneVersionResolver(chainsel.FamilyEVM, &adapters1_2.LaneVersionResolver{})
 	ccvadapters.GetIndexerConfigRegistry().Register(chainsel.FamilyEVM, &EVMIndexerConfigAdapter{})
 	ccvadapters.GetAggregatorConfigRegistry().Register(chainsel.FamilyEVM, &EVMAggregatorConfigAdapter{})
 	ccvadapters.GetTokenVerifierConfigRegistry().Register(chainsel.FamilyEVM, &EVMTokenVerifierConfigAdapter{})

chains/evm/deployment/v1_2_0/adapters/laneversionresolver.go

@@ -7,11 +7,13 @@ import (
 	"github.com/Masterminds/semver/v3"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/smartcontractkit/chainlink-ccip/chains/evm/gobindings/generated/v1_2_0/router"
+	chain_selectors "github.com/smartcontractkit/chain-selectors"
 	"github.com/smartcontractkit/chainlink-deployments-framework/chain/evm"
 	"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
 	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
 
+	"github.com/smartcontractkit/chainlink-ccip/chains/evm/gobindings/generated/v1_2_0/router"
+
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/utils"
 	evm_datastore_utils "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/utils/datastore"
 	routerops "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_2_0/operations/router"
@@ -20,6 +22,22 @@ import (
 
 type LaneVersionResolver struct{}
 
+func (r *LaneVersionResolver) IsSupportedChain(e cldf.Environment, chainSel uint64) bool {
+	family, err := chain_selectors.GetSelectorFamily(chainSel)
+	if err != nil || family != chain_selectors.FamilyEVM {
+		return false
+	}
+	_, err = datastore_utils.FindAndFormatRef(e.DataStore, datastore.AddressRef{
+		Type:          datastore.ContractType(routerops.ContractType),
+		Version:       routerops.Version,
+		ChainSelector: chainSel,
+	}, chainSel, evm_datastore_utils.ToEVMAddress)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
 // DeriveLaneVersionsForChain derives the versions of the lanes for a given chain by looking at the router's offramps and onramps.
 // It returns a map of remote chain selector to lane version, a list of unique lane versions, and an error if any.
 func (r *LaneVersionResolver) DeriveLaneVersionsForChain(e cldf.Environment, chainSel uint64) (map[uint64]*semver.Version, []*semver.Version, error) {

deployment/deploy/product.go

@@ -108,5 +108,7 @@ type ConfigImporter interface {
 // For example - in case of EVM chains, we can look at the onramps and offramps connected to the router to determine
 // which version of the lane is deployed for each remote chain.
 type LaneVersionResolver interface {
+	// IsSupportedChain checks if the given chain selector corresponds to a chain that is supported by this lane version resolver.
+	IsSupportedChain(e cldf.Environment, chainSel uint64) bool
 	DeriveLaneVersionsForChain(e cldf.Environment, chainSel uint64) (map[uint64]*semver.Version, []*semver.Version, error)
 }

deployment/v1_7_0/adapters/deploy_chain_contracts.go

@@ -123,9 +123,10 @@ type DeployChainContractsAdapter interface {
 }
 
 type DeployChainContractsRegistry struct {
-	mu              sync.Mutex
-	adapters        map[string]DeployChainContractsAdapter
-	configImporters map[string]deploy.ConfigImporter
+	mu                  sync.Mutex
+	adapters            map[string]DeployChainContractsAdapter
+	configImporters     map[string]deploy.ConfigImporter
+	laneVersionResolver map[string]deploy.LaneVersionResolver
 }
 
 var (
@@ -135,8 +136,9 @@ var (
 
 func NewDeployChainContractsRegistry() *DeployChainContractsRegistry {
 	return &DeployChainContractsRegistry{
-		adapters:        make(map[string]DeployChainContractsAdapter),
-		configImporters: make(map[string]deploy.ConfigImporter),
+		adapters:            make(map[string]DeployChainContractsAdapter),
+		configImporters:     make(map[string]deploy.ConfigImporter),
+		laneVersionResolver: make(map[string]deploy.LaneVersionResolver),
 	}
 }
 
@@ -164,6 +166,25 @@ func (r *DeployChainContractsRegistry) RegisterConfigImporter(family string, ver
 	}
 }
 
+func (r *DeployChainContractsRegistry) RegisterLaneVersionResolver(family string, resolver deploy.LaneVersionResolver) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if _, exists := r.laneVersionResolver[family]; !exists {
+		r.laneVersionResolver[family] = resolver
+	}
+}
+
+func (r *DeployChainContractsRegistry) GetLaneVersionResolver(sel uint64) (deploy.LaneVersionResolver, bool) {
+	family, err := chainsel.GetSelectorFamily(sel)
+	if err != nil {
+		return nil, false
+	}
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	resolver, ok := r.laneVersionResolver[family]
+	return resolver, ok
+}
+
 func (r *DeployChainContractsRegistry) Get(family string) (DeployChainContractsAdapter, bool) {
 	r.mu.Lock()
 	defer r.mu.Unlock()

deployment/v1_7_0/changesets/deploy_chain_contracts.go

@@ -137,38 +137,44 @@ func DeployChainContracts(registry *adapters.DeployChainContractsRegistry) deplo
 				},
 			}
 			if !cfg.Cfg.IgnoreImportedConfigFromPreviousVersion {
-				// so far we do not need any config from 1.5.0 , so only importing config from 1.6.0
-				// if in the future we need to import some config from 1.5.0,
-				// we should leverage lane version resolver to get the right adapter to import config
-				version := semver.MustParse("1.6.0")
-				configImporter, ok := registry.GetConfigImporter(sel, version)
-				if !ok {
-					return deployment.ChangesetOutput{}, utils.ErrNoAdapterForSelectorRegistered("ConfigImporter", sel, version)
-				}
-				populateCfgOutput, err := deploy.PopulateMetaDataFromConfigImporter(e, configImporter, sel)
+				importNeeded, err := shouldImportConfigFromPreviousVersion(e, registry, sel)
 				if err != nil {
-					return deployment.ChangesetOutput{}, fmt.Errorf("failed to populate metadata from config importer for chain %d: %w", sel, err)
+					return deployment.ChangesetOutput{}, fmt.Errorf("failed to check if config import from previous version is needed for chain %d: %w", sel, err)
 				}
-				// if the importer found config from previous version,
-				// import it and merge it with the input config, giving precedence to the imported config
-				if len(populateCfgOutput.Metadata.Contracts) > 0 {
-					importReport, err := operations.ExecuteSequence(
-						e.OperationsBundle,
-						adapter.SetContractParamsFromImportedConfig(),
-						e.BlockChains, adapters.DeployChainConfigCreatorInput{
-							ChainSelector:      sel,
-							ContractMeta:       populateCfgOutput.Metadata.Contracts,
-							ExistingAddresses:  existingAddresses,
-							UserProvidedConfig: input.ContractParams,
-						})
-					if err != nil {
-						return deployment.ChangesetOutput{Reports: allReports},
-							fmt.Errorf("failed to execute config importer sequence for chain %d: %w", sel, err)
+				if importNeeded {
+					// so far we do not need any config from 1.5.0 , so only importing config from 1.6.0
+					// if in the future we need to import some config from 1.5.0,
+					// we should leverage lane version resolver to get the right adapter to import config
+					version := semver.MustParse("1.6.0")
+					configImporter, ok := registry.GetConfigImporter(sel, version)
+					if !ok {
+						return deployment.ChangesetOutput{}, utils.ErrNoAdapterForSelectorRegistered("ConfigImporter", sel, version)
 					}
-					allReports = append(allReports, importReport.ExecutionReports...)
-					input.ContractParams, err = input.ContractParams.MergeWithOverrideIfNotEmpty(importReport.Output)
+					populateCfgOutput, err := deploy.PopulateMetaDataFromConfigImporter(e, configImporter, sel)
 					if err != nil {
-						return deployment.ChangesetOutput{}, fmt.Errorf("failed to merge imported config with input config for chain %d: %w", sel, err)
+						return deployment.ChangesetOutput{}, fmt.Errorf("failed to populate metadata from config importer for chain %d: %w", sel, err)
+					}
+					// if the importer found config from previous version,
+					// import it and merge it with the input config, giving precedence to the imported config
+					if len(populateCfgOutput.Metadata.Contracts) > 0 {
+						importReport, err := operations.ExecuteSequence(
+							e.OperationsBundle,
+							adapter.SetContractParamsFromImportedConfig(),
+							e.BlockChains, adapters.DeployChainConfigCreatorInput{
+								ChainSelector:      sel,
+								ContractMeta:       populateCfgOutput.Metadata.Contracts,
+								ExistingAddresses:  existingAddresses,
+								UserProvidedConfig: input.ContractParams,
+							})
+						if err != nil {
+							return deployment.ChangesetOutput{Reports: allReports},
+								fmt.Errorf("failed to execute config importer sequence for chain %d: %w", sel, err)
+						}
+						allReports = append(allReports, importReport.ExecutionReports...)
+						input.ContractParams, err = input.ContractParams.MergeWithOverrideIfNotEmpty(importReport.Output)
+						if err != nil {
+							return deployment.ChangesetOutput{}, fmt.Errorf("failed to merge imported config with input config for chain %d: %w", sel, err)
+						}
 					}
 				}
 			}
@@ -263,3 +269,26 @@ func BuildCommitteeVerifierParams(
 
 	return params, nil
 }
+
+// shouldImportConfigFromPreviousVersion checks if any of the lanes connected to the given chain selector are using version 1.6.0,
+// if so, it returns true, indicating that we should import config from previous version, otherwise it returns false
+func shouldImportConfigFromPreviousVersion(e deployment.Environment, registry *adapters.DeployChainContractsRegistry, sel uint64) (bool, error) {
+	res, exists := registry.GetLaneVersionResolver(sel)
+	if !exists {
+		return false, fmt.Errorf("no lane version resolver registered for chain %d", sel)
+	}
+	if !res.IsSupportedChain(e, sel) {
+		return false, nil
+	}
+	_, versions, err := res.DeriveLaneVersionsForChain(e, sel)
+	if err != nil {
+		return false, fmt.Errorf("failed to derive lane versions for chain %d: %w", sel, err)
+	}
+	reqVersion := semver.MustParse("1.6.0")
+	for _, v := range versions {
+		if v.Equal(reqVersion) {
+			return true, nil
+		}
+	}
+	return false, nil
+}

deployment/v1_7_0/changesets/deploy_chain_contracts_test.go

@@ -35,6 +35,14 @@ type mockDeployAdapter struct {
 	errByChain    map[uint64]error
 }
 
+func (m *mockDeployAdapter) IsSupportedChain(_ deployment.Environment, _ uint64) bool {
+	return false
+}
+
+func (m *mockDeployAdapter) DeriveLaneVersionsForChain(_ deployment.Environment, _ uint64) (map[uint64]*semver.Version, []*semver.Version, error) {
+	return map[uint64]*semver.Version{}, []*semver.Version{}, nil
+}
+
 func (m *mockDeployAdapter) InitializeAdapter(_ deployment.Environment, _ uint64) error {
 	return nil
 }
@@ -285,41 +293,6 @@ func TestDeployChainContracts_Validate(t *testing.T) {
 	}
 }
 
-func TestDeployChainContracts_With_MissingAdapterForConfigImport(t *testing.T) {
-	sel1 := chainsel.TEST_90000001.Selector
-	env := newDeployTestEnv(t, []uint64{sel1})
-
-	expectedAddr := datastore.AddressRef{
-		ChainSelector: sel1,
-		Type:          "TestContract",
-		Version:       semver.MustParse("2.0.0"),
-		Address:       "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
-	}
-
-	mock := &mockDeployAdapter{
-		outputByChain: map[uint64]sequences.OnChainOutput{
-			sel1: {
-				Addresses: []datastore.AddressRef{expectedAddr},
-			},
-		},
-	}
-
-	registry := adapters.NewDeployChainContractsRegistry()
-	registry.Register(chainsel.FamilyEVM, mock)
-
-	cs := changesets.DeployChainContracts(registry)
-	_, err := cs.Apply(env, cs_core.WithMCMS[changesets.DeployChainContractsCfg]{
-		MCMS: mcms.Input{},
-		Cfg: changesets.DeployChainContractsCfg{
-			Topology:       newDeployTestTopology(sel1),
-			ChainSelectors: []uint64{sel1},
-			DefaultCfg:     newDefaultPerChainCfg(),
-		},
-	})
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "no ConfigImporter adapter registered")
-}
-
 func TestDeployChainContracts_With_DummyConfigImport(t *testing.T) {
 	sel1 := chainsel.TEST_90000001.Selector
 	env := newDeployTestEnv(t, []uint64{sel1})
@@ -334,7 +307,7 @@ func TestDeployChainContracts_With_DummyConfigImport(t *testing.T) {
 	}
 	registry := adapters.NewDeployChainContractsRegistry()
 	registry.Register(chainsel.FamilyEVM, mock)
-	registry.RegisterConfigImporter(chainsel.FamilyEVM, semver.MustParse("1.6.0"), &mockDeployAdapter{})
+	registry.RegisterLaneVersionResolver(chainsel.FamilyEVM, mock)
 
 	cs := changesets.DeployChainContracts(registry)
 	_, err := cs.Apply(env, cs_core.WithMCMS[changesets.DeployChainContractsCfg]{