[Local CRE] Move Vault OCR config to CapRegistry

Author: bolekk

core/services/ocr/capregconfig/digest.go

@@ -11,9 +11,10 @@ import (
 	capabilitiespb "github.com/smartcontractkit/chainlink-common/pkg/capabilities/pb"
 )
 
-// Offchain digest specific to OCR configs stored in CRE's CapabilitiesRegistry contract.
-// Includes donID and capabilityID to ensure uniqueness across different protocol instances.
-func computeConfigDigest(
+// ComputeConfigDigest computes the offchain digest for OCR configs stored in CRE's
+// CapabilitiesRegistry contract. Includes donID and capabilityID to ensure uniqueness
+// across different protocol instances.
+func ComputeConfigDigest(
 	chainID uint64,
 	registryAddress string,
 	capabilityID string,

core/services/ocr/capregconfig/ocrconfigservice.go

@@ -267,7 +267,7 @@ func (s *ocrConfigService) parseOCR3Config(
 		transmitters[i] = ocrtypes.Account(gethCommon.BytesToAddress(transmitter).Hex())
 	}
 
-	digest, err := computeConfigDigest(s.chainID, s.registryAddress, capabilityID, donID, ocrConfigKey, cfg)
+	digest, err := ComputeConfigDigest(s.chainID, s.registryAddress, capabilityID, donID, ocrConfigKey, cfg)
 	if err != nil {
 		return ocrtypes.ContractConfig{}, fmt.Errorf("failed to compute config digest: %w", err)
 	}

deployment/cre/jobs/propose_job_spec.go

@@ -166,10 +166,15 @@ func (u ProposeJobSpec) Apply(e cldf.Environment, input ProposeJobSpecInput) (cl
 
 		dkgContractAddr := ""
 		if jobInput.DKGContractQualifier != "" {
-			dkgContractRefKey := pkg.GetOCR3CapabilityAddressRefKey(uint64(jobInput.ChainSelectorEVM), jobInput.DKGContractQualifier)
-			addr, err := e.DataStore.Addresses().Get(dkgContractRefKey)
+			var dkgAddrRefKey datastore.AddressRefKey
+			if jobInput.CapRegVersion != "" {
+				dkgAddrRefKey = pkg.GetCapRegAddressRefKey(uint64(jobInput.ChainSelectorEVM), jobInput.DKGContractQualifier, jobInput.CapRegVersion)
+			} else {
+				dkgAddrRefKey = pkg.GetOCR3CapabilityAddressRefKey(uint64(jobInput.ChainSelectorEVM), jobInput.DKGContractQualifier)
+			}
+			addr, err := e.DataStore.Addresses().Get(dkgAddrRefKey)
 			if err != nil {
-				return cldf.ChangesetOutput{}, fmt.Errorf("failed to get OCR3 contract address for chain selector %d and qualifier %s: %w", jobInput.ChainSelectorEVM, jobInput.ContractQualifier, err)
+				return cldf.ChangesetOutput{}, fmt.Errorf("failed to get contract address for chain selector %d and qualifier %s: %w", jobInput.ChainSelectorEVM, jobInput.DKGContractQualifier, err)
 			}
 
 			dkgContractAddr = addr.Address

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

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
+	chainselectors "github.com/smartcontractkit/chain-selectors"
 	"google.golang.org/protobuf/proto"
 
 	"github.com/smartcontractkit/chainlink-common/keystore/corekeys/p2pkey"
@@ -30,6 +31,7 @@ import (
 	cap_reg_v2_seq "github.com/smartcontractkit/chainlink/deployment/cre/capabilities_registry/v2/changeset/sequences"
 	cre_contracts "github.com/smartcontractkit/chainlink/deployment/cre/contracts"
 	"github.com/smartcontractkit/chainlink/deployment/cre/ocr3"
+	"github.com/smartcontractkit/chainlink/deployment/cre/ocr3/ocr3_1"
 	keystone_changeset "github.com/smartcontractkit/chainlink/deployment/keystone/changeset"
 	ks_contracts_op "github.com/smartcontractkit/chainlink/deployment/keystone/changeset/operations/contracts"
 	libc "github.com/smartcontractkit/chainlink/system-tests/lib/conversions"
@@ -178,6 +180,93 @@ func (d *dons) embedOCR3Config(capConfig *capabilitiespb.CapabilityConfig, don d
 	return nil
 }
 
+type embedOCR3_1Params struct {
+	capRegAddress  string
+	chainID        uint64
+	donID          uint32
+	capabilityID   string
+}
+
+func (d *dons) embedOCR3_1Config(capConfig *capabilitiespb.CapabilityConfig, don donConfig, registryChainSelector uint64, configs map[string]*cre.OCR3_1ConfigEntry, params embedOCR3_1Params) error {
+	var allNodeIDs []string
+	for _, nop := range don.Nops {
+		allNodeIDs = append(allNodeIDs, nop.Nodes...)
+	}
+
+	nodes, err := deployment.NodeInfo(allNodeIDs, d.offChain)
+	if err != nil {
+		return fmt.Errorf("failed to get node info: %w", err)
+	}
+
+	if capConfig.Ocr3Configs == nil {
+		capConfig.Ocr3Configs = make(map[string]*capabilitiespb.OCR3Config)
+	}
+
+	sortedKeys := make([]string, 0, len(configs))
+	for k := range configs {
+		sortedKeys = append(sortedKeys, k)
+	}
+	sort.Strings(sortedKeys)
+
+	generateConfig := func(ocrConfigKey string, entry *cre.OCR3_1ConfigEntry) error {
+		entry.Config.TransmissionSchedule = []int{len(don.Nops[0].Nodes)}
+
+		ocrConfig, err := ocr3_1.GenerateOCR3_1ConfigFromNodes(*entry.Config, nodes, registryChainSelector, d.env.OCRSecrets, entry.ReportingPluginConfig)
+		if err != nil {
+			return fmt.Errorf("failed to generate OCR3_1 config for key %s: %w", ocrConfigKey, err)
+		}
+
+		transmitterBytes := make([][]byte, len(ocrConfig.Transmitters))
+		for i, t := range ocrConfig.Transmitters {
+			transmitterBytes[i] = t.Bytes()
+		}
+
+		capConfig.Ocr3Configs[ocrConfigKey] = &capabilitiespb.OCR3Config{
+			Signers:               ocrConfig.Signers,
+			Transmitters:          transmitterBytes,
+			F:                     uint32(ocrConfig.F),
+			OnchainConfig:         ocrConfig.OnchainConfig,
+			OffchainConfigVersion: ocrConfig.OffchainConfigVersion,
+			OffchainConfig:        ocrConfig.OffchainConfig,
+			ConfigCount:           1,
+		}
+		return nil
+	}
+
+	// Pass 1: generate configs with static ReportingPluginConfig
+	for _, key := range sortedKeys {
+		entry := configs[key]
+		if entry.ReportingPluginConfig != nil {
+			if err := generateConfig(key, entry); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Pass 2: generate configs using ReportingPluginConfigFactory (may depend on pass 1 results)
+	for _, key := range sortedKeys {
+		entry := configs[key]
+		if entry.ReportingPluginConfig != nil {
+			continue
+		}
+		if entry.ReportingPluginConfigFactory == nil {
+			return fmt.Errorf("OCR3_1 config entry for key %q has neither ReportingPluginConfig nor ReportingPluginConfigFactory", key)
+		}
+
+		rpc, err := entry.ReportingPluginConfigFactory(params.capRegAddress, params.chainID, params.donID, params.capabilityID, capConfig.Ocr3Configs)
+		if err != nil {
+			return fmt.Errorf("ReportingPluginConfigFactory failed for key %q: %w", key, err)
+		}
+		entry.ReportingPluginConfig = rpc
+
+		if err := generateConfig(key, entry); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (d *dons) mustToV2ConfigureInput(chainSelector uint64, contractAddress string, capabilityToOCR3Config map[string]*ocr3.OracleConfig) cap_reg_v2_seq.ConfigureCapabilitiesRegistryInput {
 	nops := make([]capabilities_registry_v2.CapabilitiesRegistryNodeOperatorParams, 0)
 	nodes := make([]contracts.NodesInput, 0)
@@ -451,6 +540,26 @@ func ConfigureCapabilityRegistry(input cre.ConfigureCapabilityRegistryInput) (Ca
 				if !cap.UseCapRegOCRConfig || cap.Config == nil {
 					continue
 				}
+
+			// Check for OCR3_1 config first (multi-instance capabilities like vault)
+			if ocr31Config := input.CapabilityToOCR3_1Config[cap.Capability.LabelledName]; ocr31Config != nil {
+				chainID, cErr := chainselectors.ChainIdFromSelector(input.ChainSelector)
+				if cErr != nil {
+					return nil, fmt.Errorf("failed to get chain ID from selector %d: %w", input.ChainSelector, cErr)
+				}
+				capID := fmt.Sprintf("%s@%s", cap.Capability.LabelledName, cap.Capability.Version)
+				params := embedOCR3_1Params{
+					capRegAddress: input.CapabilitiesRegistryAddress.Hex(),
+					chainID:       chainID,
+					donID:         don.id,
+					capabilityID:  capID,
+				}
+				if err := dons.embedOCR3_1Config(don.Capabilities[i].Config, don, input.ChainSelector, ocr31Config.Configs, params); err != nil {
+					return nil, fmt.Errorf("failed to embed OCR3_1 config for capability %s: %w", cap.Capability.LabelledName, err)
+				}
+				continue
+			}
+
 				ocrConfig := input.CapabilityToOCR3Config[cap.Capability.LabelledName]
 				if ocrConfig == nil {
 					return nil, fmt.Errorf("no OCR3 config found for capability %s", cap.Capability.LabelledName)

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

@@ -190,6 +190,7 @@ func SetupTestEnvironment(
 	fmt.Print(libformat.PurpleText("%s", input.StageGen.Wrap("Applying Features before environment startup")))
 	var donsCapabilities = make(map[uint64][]keystone_changeset.DONCapabilityWithConfig)
 	var capabilityToOCR3Config = make(map[string]*ocr3.OracleConfig)
+	var capabilityToOCR3_1Config = make(map[string]*cre.OCR3_1CapabilityConfig)
 	for _, feature := range input.Features.List() {
 		for _, donMetadata := range topology.DonsMetadataWithFlag(feature.Flag()) {
 			testLogger.Info().Msgf("Executing PreEnvStartup for feature %s for don '%s'", feature.Flag(), donMetadata.Name)
@@ -209,6 +210,7 @@ func SetupTestEnvironment(
 				}
 				donsCapabilities[donMetadata.ID] = append(donsCapabilities[donMetadata.ID], output.DONCapabilityWithConfig...)
 				maps.Copy(capabilityToOCR3Config, output.CapabilityToOCR3Config)
+				maps.Copy(capabilityToOCR3_1Config, output.CapabilityToOCR3_1Config)
 			}
 			testLogger.Info().Msgf("PreEnvStartup for feature %s executed successfully", feature.Flag())
 		}
@@ -383,6 +385,7 @@ func SetupTestEnvironment(
 		WithV2Registries:         input.WithV2Registries,
 		DONCapabilityWithConfigs: make(map[uint64][]keystone_changeset.DONCapabilityWithConfig),
 		CapabilityToOCR3Config:   capabilityToOCR3Config,
+		CapabilityToOCR3_1Config: capabilityToOCR3_1Config,
 	}
 
 	for _, capability := range input.Capabilities {