[CRE-762] rename homeChain* to registryChain* variables

core/scripts/cre/environment/README.md

@@ -816,7 +816,7 @@ Add default configuration and binary path to `core/scripts/cre/environment/confi
 Add your capability to the default set in `system-tests/lib/cre/capabilities/sets/sets.go`:
 
 ```go
-func NewDefaultSet(homeChainID uint64, extraAllowedPorts []int, extraAllowedIPs []string, extraAllowedIPsCIDR []string) ([]cre.InstallableCapability, error) {
+func NewDefaultSet(registryChainID uint64, extraAllowedPorts []int, extraAllowedIPs []string, extraAllowedIPsCIDR []string) ([]cre.InstallableCapability, error) {
     capabilities := []cre.InstallableCapability{}
 
     // ... existing capabilities ...

core/scripts/cre/environment/environment/environment.go

@@ -343,9 +343,9 @@ func startCmd() *cobra.Command {
 				return errors.Wrap(startErr, "failed to start environment")
 			}
 
-			homeChainOut := output.CreEnvironment.Blockchains[0]
+			registryChainOut := output.CreEnvironment.Blockchains[0]
 
-			sErr := StartCmdGenerateSettingsFile(homeChainOut, output)
+			sErr := StartCmdGenerateSettingsFile(registryChainOut, output)
 			if sErr != nil {
 				fmt.Fprintf(os.Stderr, "failed to create CRE CLI settings file: %s. You need to create it manually.", sErr)
 			}
@@ -455,7 +455,7 @@ func startCmd() *cobra.Command {
 				if wErr != nil {
 					return errors.Wrap(wErr, "failed to get workflow DON")
 				}
-				deployErr := deployAndVerifyExampleWorkflow(cmdContext, homeChainOut.CtfOutput().Nodes[0].ExternalHTTPUrl, gatewayURL, workflowDON.Name, workflowDonID, exampleWorkflowTimeout, exampleWorkflowTrigger, wfRegAddr.Hex())
+				deployErr := deployAndVerifyExampleWorkflow(cmdContext, registryChainOut.CtfOutput().Nodes[0].ExternalHTTPUrl, gatewayURL, workflowDON.Name, workflowDonID, exampleWorkflowTimeout, exampleWorkflowTrigger, wfRegAddr.Hex())
 				if deployErr != nil {
 					fmt.Printf("Failed to deploy and verify example workflow: %s\n", deployErr)
 				}

system-tests/lib/cre/contracts/keystone.go

@@ -56,8 +56,8 @@ func DeployKeystoneContracts(
 ) (*DeployKeystoneContractsOutput, error) {
 	memoryDatastore := datastore.NewMemoryDataStore()
 
-	homeChainOutput := input.CtfBlockchains[0]
-	homeChainSelector := homeChainOutput.ChainSelector()
+	registryChainOutput := input.CtfBlockchains[0]
+	registryChainSelector := registryChainOutput.ChainSelector()
 	deployRegistrySeq := ks_contracts_op.DeployRegistryContractsSequence
 	if input.WithV2Registries {
 		deployRegistrySeq = ks_contracts_op.DeployV2RegistryContractsSequence
@@ -70,7 +70,7 @@ func DeployKeystoneContracts(
 			Env: input.CldfEnvironment,
 		},
 		ks_contracts_op.DeployRegistryContractsSequenceInput{
-			RegistryChainSelector: homeChainSelector,
+			RegistryChainSelector: registryChainSelector,
 		},
 	)
 	if seqErr != nil {
@@ -85,11 +85,11 @@ func DeployKeystoneContracts(
 		return nil, errors.Wrap(err, "failed to merge datastore with Keystone contracts addresses")
 	}
 
-	wfRegAddr := MustGetAddressFromMemoryDataStore(memoryDatastore, homeChainSelector, keystone_changeset.WorkflowRegistry.String(), input.ContractVersions[keystone_changeset.WorkflowRegistry.String()], "")
-	testLogger.Info().Msgf("Deployed Workflow Registry %s contract on chain %d at %s", input.ContractVersions[keystone_changeset.WorkflowRegistry.String()], homeChainSelector, wfRegAddr)
+	wfRegAddr := MustGetAddressFromMemoryDataStore(memoryDatastore, registryChainSelector, keystone_changeset.WorkflowRegistry.String(), input.ContractVersions[keystone_changeset.WorkflowRegistry.String()], "")
+	testLogger.Info().Msgf("Deployed Workflow Registry %s contract on chain %d at %s", input.ContractVersions[keystone_changeset.WorkflowRegistry.String()], registryChainSelector, wfRegAddr)
 
-	capRegAddr := MustGetAddressFromMemoryDataStore(memoryDatastore, homeChainSelector, keystone_changeset.CapabilitiesRegistry.String(), input.ContractVersions[keystone_changeset.CapabilitiesRegistry.String()], "")
-	testLogger.Info().Msgf("Deployed Capabilities Registry %s contract on chain %d at %s", input.ContractVersions[keystone_changeset.CapabilitiesRegistry.String()], homeChainSelector, capRegAddr)
+	capRegAddr := MustGetAddressFromMemoryDataStore(memoryDatastore, registryChainSelector, keystone_changeset.CapabilitiesRegistry.String(), input.ContractVersions[keystone_changeset.CapabilitiesRegistry.String()], "")
+	testLogger.Info().Msgf("Deployed Capabilities Registry %s contract on chain %d at %s", input.ContractVersions[keystone_changeset.CapabilitiesRegistry.String()], registryChainSelector, capRegAddr)
 
 	input.CldfEnvironment.DataStore = memoryDatastore.Seal()
 

system-tests/lib/cre/don/config/config.go

@@ -110,7 +110,7 @@ func PrepareNodeTOMLs(
 					Flags:                   donMetadata.Flags,
 					CapabilitiesPeeringData: capabilitiesPeeringData,
 					OCRPeeringData:          ocrPeeringData,
-					HomeChainSelector:       creEnv.RegistryChainSelector,
+					RegistryChainSelector:   creEnv.RegistryChainSelector,
 					GatewayConnectorOutput:  topology.GatewayConnectors,
 					NodeSet:                 localNodeSets[i],
 					CapabilityConfigs:       creEnv.CapabilityConfigs,
@@ -438,7 +438,7 @@ type commonInputs struct {
 }
 
 func gatherCommonInputs(input cre.GenerateConfigsInput) (*commonInputs, error) {
-	registryChainID, homeErr := chain_selectors.ChainIdFromSelector(input.HomeChainSelector)
+	registryChainID, homeErr := chain_selectors.ChainIdFromSelector(input.RegistryChainSelector)
 	if homeErr != nil {
 		return nil, errors.Wrap(homeErr, "failed to get home chain ID")
 	}
@@ -451,19 +451,19 @@ func gatherCommonInputs(input cre.GenerateConfigsInput) (*commonInputs, error) {
 	}
 
 	// find contract addresses
-	capabilitiesRegistryAddress, capRegTypeVersion, capErr := crecontracts.FindAddressesForChain(input.AddressBook, input.HomeChainSelector, keystone_changeset.CapabilitiesRegistry.String())
+	capabilitiesRegistryAddress, capRegTypeVersion, capErr := crecontracts.FindAddressesForChain(input.AddressBook, input.RegistryChainSelector, keystone_changeset.CapabilitiesRegistry.String())
 	if capErr != nil {
 		return nil, errors.Wrap(capErr, "failed to find CapabilitiesRegistry address")
 	}
 
-	workflowRegistryAddress, wfRegTypeVersion, wfErr := crecontracts.FindAddressesForChain(input.AddressBook, input.HomeChainSelector, keystone_changeset.WorkflowRegistry.String())
+	workflowRegistryAddress, wfRegTypeVersion, wfErr := crecontracts.FindAddressesForChain(input.AddressBook, input.RegistryChainSelector, keystone_changeset.WorkflowRegistry.String())
 	if wfErr != nil {
 		return nil, errors.Wrap(wfErr, "failed to find WorkflowRegistry address")
 	}
 
 	return &commonInputs{
 		registryChainID:       registryChainID,
-		registryChainSelector: input.HomeChainSelector,
+		registryChainSelector: input.RegistryChainSelector,
 		workflowRegistry: addressTypeVersion{
 			address:     workflowRegistryAddress,
 			versionType: wfRegTypeVersion,

system-tests/lib/cre/environment/create_jd_jobs_op.go

@@ -14,14 +14,14 @@ import (
 )
 
 type CreateJobsWithJdOpDeps struct {
-	Logger                    zerolog.Logger
-	SingleFileLogger          common.Logger
-	HomeChainBlockchainOutput *blockchain.Output
-	JobSpecFactoryFunctions   []cre.JobSpecFn
-	CreEnvironment            *cre.Environment
-	Dons                      *cre.Dons
-	NodeSets                  []*cre.NodeSet
-	Capabilities              []cre.InstallableCapability
+	Logger                        zerolog.Logger
+	SingleFileLogger              common.Logger
+	RegistryChainBlockchainOutput *blockchain.Output
+	JobSpecFactoryFunctions       []cre.JobSpecFn
+	CreEnvironment                *cre.Environment
+	Dons                          *cre.Dons
+	NodeSets                      []*cre.NodeSet
+	Capabilities                  []cre.InstallableCapability
 }
 
 type CreateJobsWithJdOpInput struct {

system-tests/lib/cre/environment/environment.go

@@ -302,14 +302,14 @@ func SetupTestEnvironment(
 	// allow to pass custom job spec factories for extensibility
 	jobSpecFactoryFunctions = append(jobSpecFactoryFunctions, input.JobSpecFactoryFunctions...)
 	createJobsDeps := CreateJobsWithJdOpDeps{
-		Logger:                    testLogger,
-		SingleFileLogger:          singleFileLogger,
-		HomeChainBlockchainOutput: deployedBlockchains.RegistryChain().CtfOutput(),
-		JobSpecFactoryFunctions:   jobSpecFactoryFunctions,
-		CreEnvironment:            creEnvironment,
-		Dons:                      dons,
-		NodeSets:                  input.NodeSets,
-		Capabilities:              input.Capabilities,
+		Logger:                        testLogger,
+		SingleFileLogger:              singleFileLogger,
+		RegistryChainBlockchainOutput: deployedBlockchains.RegistryChain().CtfOutput(),
+		JobSpecFactoryFunctions:       jobSpecFactoryFunctions,
+		CreEnvironment:                creEnvironment,
+		Dons:                          dons,
+		NodeSets:                      input.NodeSets,
+		Capabilities:                  input.Capabilities,
 	}
 	_, createJobsErr := operations.ExecuteOperation(deployKeystoneContractsOutput.Env.OperationsBundle, CreateJobsWithJdOp, createJobsDeps, CreateJobsWithJdOpInput{})
 	if createJobsErr != nil {

system-tests/lib/cre/features/vault/vault.go

@@ -281,7 +281,7 @@ func createJobs(
 	return jobs.Create(ctx, jdClient, dons, jobSpecs)
 }
 
-func deployVaultContracts(testLogger zerolog.Logger, qualifier string, homeChainSelector uint64, env *cldf.Environment, contractVersions map[string]string) (*common.Address, *common.Address, error) {
+func deployVaultContracts(testLogger zerolog.Logger, qualifier string, registryChainSelector uint64, env *cldf.Environment, contractVersions map[string]string) (*common.Address, *common.Address, error) {
 	memoryDatastore := datastore.NewMemoryDataStore()
 
 	// load all existing addresses into memory datastore
@@ -297,21 +297,21 @@ func deployVaultContracts(testLogger zerolog.Logger, qualifier string, homeChain
 			Env: env,
 		},
 		creseq.DeployVaultInput{
-			ChainSelector: homeChainSelector,
+			ChainSelector: registryChainSelector,
 			Qualifier:     qualifier,
 		},
 	)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to deploy OCR3 contract '%s' on chain %d: %w", qualifier, homeChainSelector, err)
+		return nil, nil, fmt.Errorf("failed to deploy OCR3 contract '%s' on chain %d: %w", qualifier, registryChainSelector, err)
 	}
 	if err = memoryDatastore.Merge(report.Output.Datastore); err != nil {
-		return nil, nil, fmt.Errorf("failed to merge datastore with OCR3 contract address for '%s' on chain %d: %w", qualifier, homeChainSelector, err)
+		return nil, nil, fmt.Errorf("failed to merge datastore with OCR3 contract address for '%s' on chain %d: %w", qualifier, registryChainSelector, err)
 	}
 
 	vaultOCR3Addr := report.Output.PluginAddress
-	testLogger.Info().Msgf("Deployed OCR3 %s (Vault) contract on chain %d at %s", contractVersions[keystone_changeset.OCR3Capability.String()], homeChainSelector, vaultOCR3Addr)
+	testLogger.Info().Msgf("Deployed OCR3 %s (Vault) contract on chain %d at %s", contractVersions[keystone_changeset.OCR3Capability.String()], registryChainSelector, vaultOCR3Addr)
 	vaultDKGOCR3Addr := report.Output.DKGAddress
-	testLogger.Info().Msgf("Deployed OCR3 %s (DKG) contract on chain %d at %s", contractVersions[keystone_changeset.OCR3Capability.String()], homeChainSelector, vaultDKGOCR3Addr)
+	testLogger.Info().Msgf("Deployed OCR3 %s (DKG) contract on chain %d at %s", contractVersions[keystone_changeset.OCR3Capability.String()], registryChainSelector, vaultDKGOCR3Addr)
 
 	env.DataStore = memoryDatastore.Seal()
 

system-tests/lib/cre/types.go

@@ -401,7 +401,7 @@ type GenerateConfigsInput struct {
 	Datastore               datastore.DataStore
 	DonMetadata             *DonMetadata
 	Blockchains             map[uint64]blockchains.Blockchain
-	HomeChainSelector       uint64
+	RegistryChainSelector   uint64
 	Flags                   []string
 	CapabilitiesPeeringData CapabilitiesPeeringData
 	OCRPeeringData          OCRPeeringData
@@ -418,7 +418,7 @@ func (g *GenerateConfigsInput) Validate() error {
 	if len(g.Blockchains) == 0 {
 		return errors.New("blockchain output not set")
 	}
-	if g.HomeChainSelector == 0 {
+	if g.RegistryChainSelector == 0 {
 		return errors.New("home chain selector not set")
 	}
 	if len(g.Flags) == 0 {
@@ -430,17 +430,17 @@ func (g *GenerateConfigsInput) Validate() error {
 	if g.OCRPeeringData == (OCRPeeringData{}) {
 		return errors.New("ocr peering data not set")
 	}
-	_, addrErr := g.AddressBook.AddressesForChain(g.HomeChainSelector)
+	_, addrErr := g.AddressBook.AddressesForChain(g.RegistryChainSelector)
 	if addrErr != nil {
-		return fmt.Errorf("failed to get addresses for chain %d: %w", g.HomeChainSelector, addrErr)
+		return fmt.Errorf("failed to get addresses for chain %d: %w", g.RegistryChainSelector, addrErr)
 	}
 	_, dsErr := g.Datastore.Addresses().Fetch()
 	if dsErr != nil {
 		return fmt.Errorf("failed to get addresses from datastore: %w", dsErr)
 	}
-	h := g.Datastore.Addresses().Filter(datastore.AddressRefByChainSelector(g.HomeChainSelector))
+	h := g.Datastore.Addresses().Filter(datastore.AddressRefByChainSelector(g.RegistryChainSelector))
 	if len(h) == 0 {
-		return fmt.Errorf("no addresses found for home chain %d in datastore", g.HomeChainSelector)
+		return fmt.Errorf("no addresses found for home chain %d in datastore", g.RegistryChainSelector)
 	}
 	// TODO check for required registry contracts by type and version
 	return nil

system-tests/lib/cre/workflow/registry.go

@@ -214,7 +214,7 @@ func ConfigureWorkflowRegistry(
 }
 
 // WaitForAllNodesToHaveExpectedFiltersRegistered manually checks if all WorkflowRegistry filters used by the LogPoller are registered for all nodes. We want to see if this will help with the flakiness.
-func WaitForAllNodesToHaveExpectedFiltersRegistered(ctx context.Context, singleFileLogger logger.Logger, testLogger zerolog.Logger, homeChainID uint64, dons *cre.Dons, nodeSet []*cre.NodeSet) error {
+func WaitForAllNodesToHaveExpectedFiltersRegistered(ctx context.Context, singleFileLogger logger.Logger, testLogger zerolog.Logger, registryChainID uint64, dons *cre.Dons, nodeSet []*cre.NodeSet) error {
 	for donIdx, don := range dons.List() {
 		if !flags.HasFlag(don.Flags, cre.WorkflowDON) {
 			continue
@@ -257,7 +257,7 @@ func WaitForAllNodesToHaveExpectedFiltersRegistered(ctx context.Context, singleF
 					}
 
 					testLogger.Info().Msgf("Checking if all WorkflowRegistry filters are registered for worker node %d", workerNode.Index)
-					allFilters, filtersErr := getAllFilters(checkCtx, singleFileLogger, big.NewInt(libc.MustSafeInt64(homeChainID)), workerNode.Index, nodeSet[donIdx].DbInput.Port)
+					allFilters, filtersErr := getAllFilters(checkCtx, singleFileLogger, big.NewInt(libc.MustSafeInt64(registryChainID)), workerNode.Index, nodeSet[donIdx].DbInput.Port)
 					if filtersErr != nil {
 						cancel()
 						ticker.Stop()

system-tests/lib/crecli/settings.go

@@ -120,7 +120,7 @@ func PrepareCRECLISettingsFile(
 	workflowOwner common.Address,
 	addressBook cldf.AddressBook,
 	donID uint64,
-	homeChainSelector uint64,
+	registryChainSelector uint64,
 	rpcs map[uint64]string,
 	s3ProviderOutput *s3provider.Output,
 ) (*os.File, error) {
@@ -129,14 +129,14 @@ func PrepareCRECLISettingsFile(
 		return nil, errors.Wrap(err, "failed to create CRE CLI settings file")
 	}
 
-	capRegAddr, _, capRegErr := contracts.FindAddressesForChain(addressBook, homeChainSelector, keystone_changeset.CapabilitiesRegistry.String())
+	capRegAddr, _, capRegErr := contracts.FindAddressesForChain(addressBook, registryChainSelector, keystone_changeset.CapabilitiesRegistry.String())
 	if capRegErr != nil {
-		return nil, errors.Wrapf(capRegErr, "failed to get capabilities registry address for chain %d", homeChainSelector)
+		return nil, errors.Wrapf(capRegErr, "failed to get capabilities registry address for chain %d", registryChainSelector)
 	}
 
-	workflowRegistryAddr, _, workflowRegistryErr := contracts.FindAddressesForChain(addressBook, homeChainSelector, keystone_changeset.WorkflowRegistry.String())
+	workflowRegistryAddr, _, workflowRegistryErr := contracts.FindAddressesForChain(addressBook, registryChainSelector, keystone_changeset.WorkflowRegistry.String())
 	if workflowRegistryErr != nil {
-		return nil, errors.Wrapf(workflowRegistryErr, "failed to get workflow registry address for chain %d", homeChainSelector)
+		return nil, errors.Wrapf(workflowRegistryErr, "failed to get workflow registry address for chain %d", registryChainSelector)
 	}
 
 	profileSettings := Settings{
@@ -155,12 +155,12 @@ func PrepareCRECLISettingsFile(
 				{
 					Name:          keystone_changeset.CapabilitiesRegistry.String(),
 					Address:       capRegAddr.Hex(),
-					ChainSelector: homeChainSelector,
+					ChainSelector: registryChainSelector,
 				},
 				{
 					Name:          keystone_changeset.WorkflowRegistry.String(),
 					Address:       workflowRegistryAddr.Hex(),
-					ChainSelector: homeChainSelector,
+					ChainSelector: registryChainSelector,
 				},
 			},
 		},

system-tests/tests/load/cre/workflow_don_load_test.go

@@ -161,10 +161,10 @@ func setupLoadTestEnvironment(
 	// Create workflow jobs only after capability registry configuration is complete to avoid initialization failures
 	createJobsInput := creenv.CreateJobsWithJdOpInput{}
 	createJobsDeps := creenv.CreateJobsWithJdOpDeps{
-		Logger:                    testLogger,
-		SingleFileLogger:          singleFileLogger,
-		HomeChainBlockchainOutput: universalSetupOutput.CreEnvironment.Blockchains[0].CtfOutput(),
-		JobSpecFactoryFunctions:   []cretypes.JobSpecFn{workflowJobsFn},
+		Logger:                        testLogger,
+		SingleFileLogger:              singleFileLogger,
+		RegistryChainBlockchainOutput: universalSetupOutput.CreEnvironment.Blockchains[0].CtfOutput(),
+		JobSpecFactoryFunctions:       []cretypes.JobSpecFn{workflowJobsFn},
 		CreEnvironment: &cretypes.Environment{
 			CldfEnvironment: universalSetupOutput.CreEnvironment.CldfEnvironment,
 		},
@@ -322,17 +322,17 @@ func TestLoad_Workflow_Streams_MockCapabilities(t *testing.T) {
 		return capabilities, nil
 	}
 
-	homeChain := in.Blockchains[0]
-	homeChainIDUint64, homeChainErr := strconv.ParseUint(homeChain.ChainID, 10, 64)
-	require.NoError(t, homeChainErr, "failed to convert chain ID to int")
+	registryChain := in.Blockchains[0]
+	registryChainIDUint64, regChainErr := strconv.ParseUint(registryChain.ChainID, 10, 64)
+	require.NoError(t, regChainErr, "failed to convert chain ID to int")
 
 	setupOutput := setupLoadTestEnvironment(
 		t,
 		testLogger,
 		in,
 		mustSetCapabilitiesFn,
 		[]cretypes.CapabilityRegistryConfigFn{WorkflowDONLoadTestCapabilitiesFactoryFn, registerEVMWithV1},
-		[]cretypes.JobSpecFn{mockJobSpecsFactoryFn, consensusJobSpec(homeChainIDUint64)},
+		[]cretypes.JobSpecFn{mockJobSpecsFactoryFn, consensusJobSpec(registryChainIDUint64)},
 		loadTestJobSpecsFactoryFn,
 	)
 

system-tests/tests/load/cre/writer_don_load_test.go

@@ -230,8 +230,8 @@ func TestLoad_Writer_MockCapabilities(t *testing.T) {
 	}
 
 	registryChain := in.Blockchains[0]
-	homeChainIDUint64, homeChainErr := strconv.ParseUint(registryChain.ChainID, 10, 64)
-	require.NoError(t, homeChainErr, "failed to convert chain ID to int")
+	registryChainIDUint64, regChainErr := strconv.ParseUint(registryChain.ChainID, 10, 64)
+	require.NoError(t, regChainErr, "failed to convert chain ID to int")
 
 	feedIDs := make([]string, 0)
 	for range in.WriterTest.NrOfFeeds {
@@ -245,7 +245,7 @@ func TestLoad_Writer_MockCapabilities(t *testing.T) {
 		in,
 		mustSetCapabilitiesFn,
 		[]cretypes.CapabilityRegistryConfigFn{WriterDONLoadTestCapabilitiesFactoryFn, registerEVMWithV1},
-		[]cretypes.JobSpecFn{loadTestJobSpecsFactoryFn, consensusJobSpec(homeChainIDUint64)},
+		[]cretypes.JobSpecFn{loadTestJobSpecsFactoryFn, consensusJobSpec(registryChainIDUint64)},
 		feedIDs,
 		[]string{in.WriterTest.WorkflowName},
 	)