Remove top level contract set (#17701)

* Removes top level contract set usage - WIP

* Removes top level contract set

* Fixes lint

* Renames map

Author: vyzaldysanchez

deployment/keystone/changeset/accept_ownership.go

@@ -21,27 +21,13 @@ var _ cldf.ChangeSet[*AcceptAllOwnershipRequest] = AcceptAllOwnershipsProposal
 // AcceptAllOwnershipsProposal creates a MCMS proposal to call accept ownership on all the Keystone contracts in the address book.
 func AcceptAllOwnershipsProposal(e cldf.Environment, req *AcceptAllOwnershipRequest) (cldf.ChangesetOutput, error) {
 	chainSelector := req.ChainSelector
-	minDelay := req.MinDelay
-	chain := e.Chains[chainSelector]
-	addrBook := e.ExistingAddresses
-
-	r, err := getContractSetsV2(e.Logger, getContractSetsRequestV2{
-		Chains: map[uint64]cldf.Chain{
-			req.ChainSelector: chain,
-		},
-		AddressBook: addrBook,
-	})
-	if err != nil {
-		return cldf.ChangesetOutput{}, err
-	}
-	contracts := r.ContractSets[chainSelector]
 
 	// Construct the configuration
 	cfg := changeset.TransferToMCMSWithTimelockConfig{
 		ContractsByChain: map[uint64][]common.Address{
-			chainSelector: contracts.transferableContracts(),
+			chainSelector: getTransferableContracts(e.DataStore.Addresses(), chainSelector),
 		},
-		MCMSConfig: proposalutils.TimelockConfig{MinDelay: minDelay},
+		MCMSConfig: proposalutils.TimelockConfig{MinDelay: req.MinDelay},
 	}
 
 	// Create and return the changeset

deployment/keystone/changeset/contract_set.go

@@ -340,31 +340,36 @@ func loadCapabilityRegistry(registryChain cldf.Chain, env cldf.Environment, ref
 	if err != nil {
 		return nil, fmt.Errorf("failed to check registry ref: %w", err)
 	}
+
 	var cr *OwnedContract[*capabilities_registry.CapabilitiesRegistry]
-	if ref != nil {
-		a, err := env.DataStore.Addresses().Get(ref)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get address: %w", err)
-		}
-		cr, err = GetOwnedContractV2[*capabilities_registry.CapabilitiesRegistry](env.DataStore.Addresses(), registryChain, a.Address)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get owned contract: %w", err)
-		}
-	} else {
-		// TODO: CRE-400 remove this once we have migrated all environments to use datastore
-		// This is a temporary backward compatibility until all the CLD environments are migrated to use datastore
-		cs, err := getContractSetsV2(env.Logger, getContractSetsRequestV2{
-			Chains:      map[uint64]cldf.Chain{registryChain.Selector: registryChain},
-			AddressBook: env.ExistingAddresses, //nolint:staticcheck  // TODO CRE-400 remove this once we have migrated all environments to use datastore
-		})
-		if err != nil {
-			return nil, fmt.Errorf("failed to get contract sets: %w", err)
-		}
-		contractSet, exists := cs.ContractSets[registryChain.Selector]
-		if !exists {
-			return nil, fmt.Errorf("contract set not found for chain %d", registryChain.Selector)
-		}
-		cr = contractSet.CapabilitiesRegistry
+
+	// `shouldUseDatastore` is already checking for the nil ref, no need to `ref == nil` here
+	a, err := env.DataStore.Addresses().Get(ref)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get address: %w", err)
+	}
+	cr, err = GetOwnedContractV2[*capabilities_registry.CapabilitiesRegistry](env.DataStore.Addresses(), registryChain, a.Address)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get owned contract: %w", err)
 	}
+
 	return cr, nil
 }
+
+func getTransferableContracts(addressStore datastore.AddressRefStore, chainSelector uint64) []common.Address {
+	var transferableContracts []common.Address
+
+	addresses := addressStore.Filter(datastore.AddressRefByChainSelector(chainSelector))
+	for _, addr := range addresses {
+		isOCR3Capability := addr.Type == datastore.ContractType(OCR3Capability)
+		isWorkflowRegistry := addr.Type == datastore.ContractType(WorkflowRegistry)
+		isKeystoneForwarder := addr.Type == datastore.ContractType(KeystoneForwarder)
+		isCapabilityRegistry := addr.Type == datastore.ContractType(CapabilitiesRegistry)
+
+		if isCapabilityRegistry || isWorkflowRegistry || isKeystoneForwarder || isOCR3Capability {
+			transferableContracts = append(transferableContracts, common.HexToAddress(addr.Address))
+		}
+	}
+
+	return transferableContracts
+}

deployment/keystone/changeset/contracts.go

@@ -10,8 +10,8 @@ import (
 	mcmstypes "github.com/smartcontractkit/mcms/types"
 
 	"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
-
 	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
+	forwarder "github.com/smartcontractkit/chainlink-evm/gethwrappers/keystone/generated/forwarder_1_0_0"
 
 	"github.com/smartcontractkit/chainlink/deployment/common/proposalutils"
 	"github.com/smartcontractkit/chainlink/deployment/keystone/changeset/internal"
@@ -129,26 +129,28 @@ func ConfigureForwardContracts(env cldf.Environment, req ConfigureForwardContrac
 		return cldf.ChangesetOutput{}, fmt.Errorf("failed to configure forward contracts: %w", err)
 	}
 
-	cresp, err := getContractSetsV2(env.Logger, getContractSetsRequestV2{
-		Chains:      env.Chains,
-		AddressBook: env.ExistingAddresses,
-	})
-	if err != nil {
-		return cldf.ChangesetOutput{}, fmt.Errorf("failed to get contract sets: %w", err)
-	}
-
 	var out cldf.ChangesetOutput
 	if req.UseMCMS() {
 		if len(r.OpsPerChain) == 0 {
 			return out, errors.New("expected MCMS operation to be non-nil")
 		}
 		for chainSelector, op := range r.OpsPerChain {
-			contracts := cresp.ContractSets[chainSelector]
+			fwrAddr, ok := r.ForwarderAddresses[chainSelector]
+			if !ok {
+				return out, fmt.Errorf("expected configured forwarder address for chain selector %d", chainSelector)
+			}
+			fwr, err := GetOwnedContractV2[*forwarder.KeystoneForwarder](env.DataStore.Addresses(), env.Chains[chainSelector], fwrAddr.String())
+			if err != nil {
+				return out, fmt.Errorf("failed to get forwarder contract for chain selector %d: %w", chainSelector, err)
+			}
+			if fwr.McmsContracts == nil {
+				return out, fmt.Errorf("expected forwarder contract %s to be owned by MCMS for chain selector %d", fwrAddr.String(), chainSelector)
+			}
 			timelocksPerChain := map[uint64]string{
-				chainSelector: contracts.Forwarder.McmsContracts.Timelock.Address().Hex(),
+				chainSelector: fwr.McmsContracts.Timelock.Address().Hex(),
 			}
 			proposerMCMSes := map[uint64]string{
-				chainSelector: contracts.Forwarder.McmsContracts.ProposerMcm.Address().Hex(),
+				chainSelector: fwr.McmsContracts.ProposerMcm.Address().Hex(),
 			}
 			inspector, err := proposalutils.McmsInspectorForChain(env, chainSelector)
 			if err != nil {

deployment/keystone/changeset/deploy_forwarder.go

@@ -7,6 +7,7 @@ import (
 	"io"
 
 	"github.com/ethereum/go-ethereum/common"
+	ocr3_capability "github.com/smartcontractkit/chainlink-evm/gethwrappers/keystone/generated/ocr3_capability_1_0_0"
 
 	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
 
@@ -82,19 +83,22 @@ func ConfigureOCR3Contract(env cldf.Environment, cfg ConfigureOCR3Config) (cldf.
 		if resp.Ops == nil {
 			return out, errors.New("expected MCMS operation to be non-nil")
 		}
-		r, err := getContractSetsV2(env.Logger, getContractSetsRequestV2{
-			Chains:      env.Chains,
-			AddressBook: env.ExistingAddresses,
-		})
+
+		chain, ok := env.Chains[cfg.ChainSel]
+		if !ok {
+			return out, fmt.Errorf("chain %d not found in environment", cfg.ChainSel)
+		}
+
+		contract, err := GetOwnedContractV2[*ocr3_capability.OCR3Capability](env.DataStore.Addresses(), chain, cfg.Address.Hex())
 		if err != nil {
-			return out, fmt.Errorf("failed to get contract sets: %w", err)
+			return out, fmt.Errorf("failed to get OCR3 contract: %w", err)
 		}
-		contracts := r.ContractSets[cfg.ChainSel]
+
 		timelocksPerChain := map[uint64]string{
-			cfg.ChainSel: contracts.OCR3[*cfg.Address].McmsContracts.Timelock.Address().Hex(),
+			cfg.ChainSel: contract.McmsContracts.Timelock.Address().Hex(),
 		}
 		proposerMCMSes := map[uint64]string{
-			cfg.ChainSel: contracts.OCR3[*cfg.Address].McmsContracts.ProposerMcm.Address().Hex(),
+			cfg.ChainSel: contract.McmsContracts.ProposerMcm.Address().Hex(),
 		}
 
 		inspector, err := proposalutils.McmsInspectorForChain(env, cfg.ChainSel)

deployment/keystone/changeset/deploy_ocr3.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
 	mcmstypes "github.com/smartcontractkit/mcms/types"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
@@ -80,7 +81,10 @@ type ConfigureForwarderContractsRequest struct {
 	UseMCMS bool
 }
 type ConfigureForwarderContractsResponse struct {
-	OpsPerChain map[uint64]mcmstypes.BatchOperation
+	// ForwarderAddresses is a map of chain selector to forwarder contract address that has been configured (non-MCMS),
+	// or will be configured (MCMS).
+	ForwarderAddresses map[uint64]common.Address
+	OpsPerChain        map[uint64]mcmstypes.BatchOperation
 }
 
 // Depreciated: use [changeset.ConfigureForwardContracts] instead
@@ -96,6 +100,7 @@ func ConfigureForwardContracts(env *cldf.Environment, req ConfigureForwarderCont
 	}
 
 	opPerChain := make(map[uint64]mcmstypes.BatchOperation)
+	forwarderAddresses := make(map[uint64]common.Address)
 	// configure forwarders on all chains
 	for _, chain := range env.Chains {
 		if _, shouldInclude := req.Chains[chain.Selector]; len(req.Chains) > 0 && !shouldInclude {
@@ -113,8 +118,10 @@ func ConfigureForwardContracts(env *cldf.Environment, req ConfigureForwarderCont
 		for k, op := range ops {
 			opPerChain[k] = op
 		}
+		forwarderAddresses[chain.Selector] = contracts.Forwarder.Address()
 	}
 	return &ConfigureForwarderContractsResponse{
-		OpsPerChain: opPerChain,
+		ForwarderAddresses: forwarderAddresses,
+		OpsPerChain:        opPerChain,
 	}, nil
 }