add address codec registry

Author: ogtownsend

core/capabilities/ccip/common/addresscodec.go

@@ -1,82 +1,7 @@
 package common
 
 import (
-	"fmt"
-
-	chainsel "github.com/smartcontractkit/chain-selectors"
-	cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+	cciptypes "github.com/smartcontractkit/chainlink-common/pkg/types/ccipocr3"
 )
 
-var _ cciptypes.AddressCodec = &AddressCodec{}
-
-// AddressCodec is a struct that holds the chain specific address codecs and
-// implements a superset of the cciptypes.AddressCodec interface.
-type AddressCodec struct {
-	registeredAddressCodecMap map[string]ChainSpecificAddressCodec
-}
-
-// NewAddressCodec is a constructor for NewAddressCodec
-func NewAddressCodec(registeredMap map[string]ChainSpecificAddressCodec) AddressCodec {
-	return AddressCodec{
-		registeredAddressCodecMap: registeredMap,
-	}
-}
-
-// AddressBytesToString converts an address from bytes to string
-func (ac AddressCodec) AddressBytesToString(addr cciptypes.UnknownAddress, chainSelector cciptypes.ChainSelector) (string, error) {
-	family, err := chainsel.GetSelectorFamily(uint64(chainSelector))
-	if err != nil {
-		return "", fmt.Errorf("failed to get chain family for selector %d: %w", chainSelector, err)
-	}
-
-	codec, exist := ac.registeredAddressCodecMap[family]
-	if !exist {
-		return "", fmt.Errorf("unsupported family for address decode type %s", family)
-	}
-
-	return codec.AddressBytesToString(addr)
-}
-
-// TransmitterBytesToString converts a transmitter account from bytes to string
-func (ac AddressCodec) TransmitterBytesToString(addr cciptypes.UnknownAddress, chainSelector cciptypes.ChainSelector) (string, error) {
-	family, err := chainsel.GetSelectorFamily(uint64(chainSelector))
-	if err != nil {
-		return "", fmt.Errorf("failed to get chain family for selector %d: %w", chainSelector, err)
-	}
-
-	codec, exist := ac.registeredAddressCodecMap[family]
-	if !exist {
-		return "", fmt.Errorf("unsupported family for transmitter decode type %s", family)
-	}
-
-	return codec.TransmitterBytesToString(addr)
-}
-
-// AddressStringToBytes converts an address from string to bytes
-func (ac AddressCodec) AddressStringToBytes(addr string, chainSelector cciptypes.ChainSelector) (cciptypes.UnknownAddress, error) {
-	family, err := chainsel.GetSelectorFamily(uint64(chainSelector))
-	if err != nil {
-		return nil, fmt.Errorf("failed to get chain family for selector %d: %w", chainSelector, err)
-	}
-	codec, exist := ac.registeredAddressCodecMap[family]
-	if !exist {
-		return nil, fmt.Errorf("unsupported family for address decode type %s", family)
-	}
-
-	return codec.AddressStringToBytes(addr)
-}
-
-// OracleIDAsAddressBytes returns valid address bytes for a given chain selector and oracle ID.
-// Used for making nil transmitters in the OCR config valid, it just means that this oracle does not support the destination chain.
-func (ac AddressCodec) OracleIDAsAddressBytes(oracleID uint8, chainSelector cciptypes.ChainSelector) ([]byte, error) {
-	family, err := chainsel.GetSelectorFamily(uint64(chainSelector))
-	if err != nil {
-		return nil, fmt.Errorf("failed to get chain family for selector %d: %w", chainSelector, err)
-	}
-	codec, exist := ac.registeredAddressCodecMap[family]
-	if !exist {
-		return nil, fmt.Errorf("unsupported family for address decode type %s", family)
-	}
-
-	return codec.OracleIDAsAddressBytes(oracleID)
-}
+type AddressCodec = cciptypes.AddressCodecMap

core/capabilities/ccip/common/addresscodecregistry.go

@@ -0,0 +1,101 @@
+package common
+
+import (
+	"sync"
+
+	cciptypes "github.com/smartcontractkit/chainlink-common/pkg/types/ccipocr3"
+)
+
+// Ensure AddressCodecRegistry implements the AddressCodecBundle interface
+var _ cciptypes.AddressCodecBundle = (*AddressCodecRegistry)(nil)
+
+// AddressCodecRegistry is a singleton registry that manages ChainSpecificAddressCodec instances
+// for different chain families. It implements the AddressCodecBundle interface
+// by delegating to the existing AddressCodec implementation.
+//
+// Terminology:
+//   - "AddressCodecRegistry": refers to the entire singleton registry instance. It both maintains the map of
+//     chain family to codec and provides thread-safe access to it.
+//   - "AddressCodecBundle": is the interface that the registry implements
+type AddressCodecRegistry struct {
+	addressCodec cciptypes.AddressCodecMap
+	mu           sync.RWMutex
+}
+
+var (
+	addressRegistryInstance *AddressCodecRegistry
+	addressRegistryOnce     sync.Once
+)
+
+// GetAddressCodecRegistry returns the singleton instance of AddressCodecRegistry. This is only called
+// in core node.
+func GetAddressCodecRegistry() *AddressCodecRegistry {
+	addressRegistryOnce.Do(func() {
+		addressRegistryInstance = &AddressCodecRegistry{
+			addressCodec: make(cciptypes.AddressCodecMap),
+		}
+	})
+	return addressRegistryInstance
+}
+
+// RegisterFamily registers a chain family with a no-op ChainSpecificAddressCodec if not already registered.
+// This is used when we know which chain families we want to support but don't have a specific codec
+// implementation initialized for it yet.
+func (r *AddressCodecRegistry) RegisterFamily(chainFamily string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if _, exists := r.addressCodec[chainFamily]; !exists {
+		r.addressCodec[chainFamily] = NoOpChainSpecificAddressCodec{}
+	}
+}
+
+// RegisterCodec registers a ChainSpecificAddressCodec for a specific chain family
+func (r *AddressCodecRegistry) RegisterCodec(chainFamily string, codec ChainSpecificAddressCodec) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.addressCodec[chainFamily] = codec
+}
+
+// ============ Implementation of AddressCodecBundle interface ============
+
+func (r *AddressCodecRegistry) AddressBytesToString(addr cciptypes.UnknownAddress, chainSelector cciptypes.ChainSelector) (string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.addressCodec.AddressBytesToString(addr, chainSelector)
+}
+
+func (r *AddressCodecRegistry) TransmitterBytesToString(addr cciptypes.UnknownAddress, chainSelector cciptypes.ChainSelector) (string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.addressCodec.TransmitterBytesToString(addr, chainSelector)
+}
+
+func (r *AddressCodecRegistry) AddressStringToBytes(addr string, chainSelector cciptypes.ChainSelector) (cciptypes.UnknownAddress, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.addressCodec.AddressStringToBytes(addr, chainSelector)
+}
+
+func (r *AddressCodecRegistry) OracleIDAsAddressBytes(oracleID uint8, chainSelector cciptypes.ChainSelector) ([]byte, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.addressCodec.OracleIDAsAddressBytes(oracleID, chainSelector)
+}
+
+type NoOpChainSpecificAddressCodec struct{}
+
+func (n NoOpChainSpecificAddressCodec) AddressBytesToString(addr []byte) (string, error) {
+	return string(addr), nil
+}
+
+func (n NoOpChainSpecificAddressCodec) AddressStringToBytes(addr string) ([]byte, error) {
+	return []byte(addr), nil
+}
+
+func (n NoOpChainSpecificAddressCodec) OracleIDAsAddressBytes(oracleID uint8) ([]byte, error) {
+	return []byte{oracleID}, nil
+}
+
+func (n NoOpChainSpecificAddressCodec) TransmitterBytesToString(addr []byte) (string, error) {
+	return string(addr), nil
+}

core/capabilities/ccip/common/extradatacodec.go

@@ -28,16 +28,6 @@ var (
 	registryOnce     sync.Once
 )
 
-type NoOpSourceChainExtraDataCodec struct{}
-
-func (n NoOpSourceChainExtraDataCodec) DecodeExtraArgsToMap(extraArgs cciptypes.Bytes) (map[string]any, error) {
-	return make(map[string]any), nil
-}
-
-func (n NoOpSourceChainExtraDataCodec) DecodeDestExecDataToMap(destExecData cciptypes.Bytes) (map[string]any, error) {
-	return make(map[string]any), nil
-}
-
 // GetExtraDataCodecRegistry returns the singleton instance of ExtraDataCodecRegistry. This is only called
 // in core node.
 func GetExtraDataCodecRegistry() *ExtraDataCodecRegistry {
@@ -91,3 +81,13 @@ func (r *ExtraDataCodecRegistry) DecodeTokenAmountDestExecData(
 	defer r.mu.RUnlock()
 	return r.extraDataCodec.DecodeTokenAmountDestExecData(destExecData, sourceChainSelector)
 }
+
+type NoOpSourceChainExtraDataCodec struct{}
+
+func (n NoOpSourceChainExtraDataCodec) DecodeExtraArgsToMap(extraArgs cciptypes.Bytes) (map[string]any, error) {
+	return make(map[string]any), nil
+}
+
+func (n NoOpSourceChainExtraDataCodec) DecodeDestExecDataToMap(destExecData cciptypes.Bytes) (map[string]any, error) {
+	return make(map[string]any), nil
+}

core/capabilities/ccip/common/extradatacodecregistry.go

@@ -29,7 +29,6 @@ type PluginConfig struct {
 // PluginServices aggregates services for a specific chain family.
 type PluginServices struct {
 	PluginConfig          PluginConfig
-	AddrCodec             AddressCodec
 	ChainRW               MultiChainRW
 	CCIPProviderSupported map[string]bool
 }
@@ -53,24 +52,25 @@ func GetPluginServices(lggr logger.Logger, chainFamily string) (PluginServices,
 
 	pluginServices := PluginServices{}
 	extraDataCodecRegistry := GetExtraDataCodecRegistry()
-	addressCodecMap := make(map[string]ChainSpecificAddressCodec)
+	addressCodecRegistry := GetAddressCodecRegistry()
 	chainRWProviderMap := make(map[string]ChainRWProvider)
 	CCIPProviderSupported := make(map[string]bool)
 
 	for family, initFunc := range registeredFactories {
 		config := initFunc(lggr, GetExtraDataCodecRegistry())
 		CCIPProviderSupported[family] = config.CCIPProviderSupported
-		if config.AddressCodec != nil {
-			addressCodecMap[family] = config.AddressCodec
-		}
 
-		// Register all known families, this includes families whose SourceChainExtraDataCodec is provided
-		// by the CCIPProvider
+		// Add all families to the registries. If the codecs are provided by the config, set them here, otherwise
+		// ccipProvider will set them later in the oracle creator.
 		extraDataCodecRegistry.RegisterFamily(family)
+		addressCodecRegistry.RegisterFamily(family)
+
 		if config.ExtraDataCodec != nil {
-			// Register the actual codec for this family if we have it defined in core already
 			extraDataCodecRegistry.RegisterCodec(family, config.ExtraDataCodec)
 		}
+		if config.AddressCodec != nil {
+			addressCodecRegistry.RegisterCodec(family, config.AddressCodec)
+		}
 		if config.ChainRW != nil {
 			chainRWProviderMap[family] = config.ChainRW
 		}
@@ -79,7 +79,6 @@ func GetPluginServices(lggr logger.Logger, chainFamily string) (PluginServices,
 		}
 	}
 
-	pluginServices.AddrCodec = NewAddressCodec(addressCodecMap)
 	pluginServices.ChainRW = NewCRCW(chainRWProviderMap)
 	pluginServices.CCIPProviderSupported = CCIPProviderSupported
 	return pluginServices, nil

core/capabilities/ccip/common/pluginconfig.go

@@ -17,13 +17,13 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/loop"
 	"github.com/smartcontractkit/chainlink-common/pkg/sqlutil"
 	"github.com/smartcontractkit/chainlink-common/pkg/types"
+	"github.com/smartcontractkit/chainlink-common/pkg/types/ccipocr3"
 	"github.com/smartcontractkit/chainlink-common/pkg/types/query/primitives"
 
+	chainsel "github.com/smartcontractkit/chain-selectors"
+
 	"github.com/smartcontractkit/chainlink-ccip/pkg/consts"
 	ccipreaderpkg "github.com/smartcontractkit/chainlink-ccip/pkg/reader"
-	cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
-
-	chainsel "github.com/smartcontractkit/chain-selectors"
 
 	kcr "github.com/smartcontractkit/chainlink-evm/gethwrappers/keystone/generated/capabilities_registry_1_1_0"
 	"github.com/smartcontractkit/chainlink-evm/pkg/config/toml"
@@ -214,11 +214,6 @@ func (d *Delegate) ServicesForSpec(ctx context.Context, spec job.Job) (services
 		return nil, fmt.Errorf("failed to get chain selector from chain ID %d", homeChainChainID)
 	}
 
-	pluginServices, err := common.GetPluginServices(d.lggr, d.capabilityConfig.ExternalRegistry().RelayID().Network)
-	if err != nil {
-		return nil, err
-	}
-
 	// if bootstrappers are provided we assume that the node is a plugin oracle.
 	// the reason for this is that bootstrap oracles do not need to be aware
 	// of other bootstrap oracles. however, plugin oracles, at least initially,
@@ -239,8 +234,7 @@ func (d *Delegate) ServicesForSpec(ctx context.Context, spec job.Job) (services
 			d.monitoringEndpointGen,
 			bootstrapperLocators,
 			hcr,
-			cciptypes.ChainSelector(homeChainChainSelector),
-			pluginServices.AddrCodec,
+			ccipocr3.ChainSelector(homeChainChainSelector),
 			p2pID,
 		)
 	} else {
@@ -251,7 +245,6 @@ func (d *Delegate) ServicesForSpec(ctx context.Context, spec job.Job) (services
 			d.monitoringEndpointGen,
 			d.lggr,
 			homeChainContractReader,
-			pluginServices.AddrCodec,
 		)
 	}
 

core/capabilities/ccip/delegate.go

@@ -4,22 +4,23 @@ import (
 	"context"
 	"fmt"
 
-	ccipcommon "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/common"
 	cctypes "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
 
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
 
+	ccipcommontypes "github.com/smartcontractkit/chainlink-common/pkg/types/ccipocr3"
+
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
 )
 
 type configTracker struct {
 	cfg            cctypes.OCR3ConfigWithMeta
-	addressCodec   ccipcommon.AddressCodec
+	addressCodec   ccipcommontypes.AddressCodecBundle
 	contractConfig types.ContractConfig
 }
 
-func NewConfigTracker(cfg cctypes.OCR3ConfigWithMeta, addressCodec ccipcommon.AddressCodec) (*configTracker, error) {
+func NewConfigTracker(cfg cctypes.OCR3ConfigWithMeta, addressCodec ccipcommontypes.AddressCodecBundle) (*configTracker, error) {
 	contractConfig, err := contractConfigFromOCRConfig(cfg, addressCodec)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create contract config from ocr config: %w", err)
@@ -51,7 +52,7 @@ func (c *configTracker) Notify() <-chan struct{} {
 	return nil
 }
 
-func contractConfigFromOCRConfig(cfg cctypes.OCR3ConfigWithMeta, addressCodec ccipcommon.AddressCodec) (types.ContractConfig, error) {
+func contractConfigFromOCRConfig(cfg cctypes.OCR3ConfigWithMeta, addressCodec ccipcommontypes.AddressCodecBundle) (types.ContractConfig, error) {
 	var signers [][]byte
 	var transmitters [][]byte
 	var err error
@@ -105,7 +106,7 @@ func toOnchainPublicKeys(signers [][]byte) []types.OnchainPublicKey {
 	return keys
 }
 
-func toOCRAccounts(transmitters [][]byte, addressCodec ccipcommon.AddressCodec, chainSelector ccipocr3.ChainSelector) ([]types.Account, error) {
+func toOCRAccounts(transmitters [][]byte, addressCodec ccipcommontypes.AddressCodecBundle, chainSelector ccipocr3.ChainSelector) ([]types.Account, error) {
 	accounts := make([]types.Account, len(transmitters))
 	for i, transmitter := range transmitters {
 		address, err := addressCodec.TransmitterBytesToString(transmitter, chainSelector)