feat: Adds MemoryContractMetadata implementation (#17059)

* feat: Adds MemoryDataStore implementation

* chore: 'github.com/stretchr/testify/assert' -> 'github.com/stretchr/testify/require'

* feat: Adds MemoryContractMetadata implementation

* feat: adds generic Metadata to ContractMetadata

* feat: adds ContractMetadataByChainSelector filter

* feat: adds generic Metadata to MemoryContractMetadataStore

* feat: adds generic Metadata to BaseDataStore

* feat: remove Merger from DataStore

* feat: improve TestMemoryDataStore_Merge

* feat: adds JSON annotation to MemoryContractMetadataStore.Records

* feat: ContractMetadata docstrings and tests

* feat: ContractMetadataKey docstrings and tests

* feat: MemoryContractMetadataStore docstrings

* chore: rename chain -> chainSelector for contractMetadataKey

* chore: TestContractMetadata_Clone add extra clone check

Author: giogam

deployment/datastore/contract_metadata.go

@@ -0,0 +1,45 @@
+package datastore
+
+import "errors"
+
+var ErrContractMetadataNotFound = errors.New("no contract metadata record can be found for the provided key")
+var ErrContractMetadataExists = errors.New("a contract metadata record with the supplied key already exists")
+
+// ContractMetadata implements the Record interface
+var _ Record[ContractMetadataKey, ContractMetadata[DefaultMetadata]] = ContractMetadata[DefaultMetadata]{}
+
+// DefaultMetadata is a default implementation of the custom contract metadata that can be used to store the
+// contract metadata in the datastore as a simple string.
+type DefaultMetadata string
+
+// DefaultMetadata implements the Cloneable interface
+func (d DefaultMetadata) Clone() DefaultMetadata { return d }
+
+// ContractMetadata is a generic struct that holds the metadata for a contract on a specific chain.
+// It implements the Record interface and is used to store contract metadata in the datastore.
+// The metadata is generic and can be of any type that implements the Cloneable interface.
+type ContractMetadata[M Cloneable[M]] struct {
+	// Address is the address of the contract on the chain.
+	Address string `json:"address"`
+	// ChainSelector is the chain-selector of the chain where the contract is deployed.
+	ChainSelector uint64 `json:"chainSelector"`
+	// Metadata is the metadata associated with the contract.
+	// It is a generic type that can be of any type that implements the Cloneable interface.
+	Metadata M `json:"metadata"`
+}
+
+// Clone creates a copy of the ContractMetadata.
+// The Metadata field is cloned using the Clone method of the Cloneable interface.
+func (r ContractMetadata[M]) Clone() ContractMetadata[M] {
+	return ContractMetadata[M]{
+		ChainSelector: r.ChainSelector,
+		Address:       r.Address,
+		Metadata:      r.Metadata.Clone(),
+	}
+}
+
+// Key returns the ContractMetadataKey for the ContractMetadata.
+// It is used to uniquely identify the contract metadata in the datastore.
+func (r ContractMetadata[M]) Key() ContractMetadataKey {
+	return NewContractMetadataKey(r.ChainSelector, r.Address)
+}

deployment/datastore/contract_metadata_key.go

@@ -0,0 +1,42 @@
+package datastore
+
+// ContractMetadataKey is an interface that represents a key for ContractMetadata records.
+// It is used to uniquely identify a record in the ContractMetadataStore.
+type ContractMetadataKey interface {
+	Comparable[ContractMetadataKey]
+
+	// Address returns the address of the contract on the chain.
+	Address() string
+	// ChainSelector returns the chain-selector of the chain where the contract is deployed.
+	ChainSelector() uint64
+}
+
+// contractMetadataKey implements the ContractMetadataKey interface.
+var _ ContractMetadataKey = contractMetadataKey{}
+
+// contractMetadataKey is a struct that implements the ContractMetadataKey interface.
+// It is used to uniquely identify a record in the ContractMetadataStore.
+type contractMetadataKey struct {
+	chainSelector uint64
+	address       string
+}
+
+// ChainSelector returns the chain-selector of the chain where the contract is deployed.
+func (c contractMetadataKey) ChainSelector() uint64 { return c.chainSelector }
+
+// Address returns the address of the contract on the chain.
+func (c contractMetadataKey) Address() string { return c.address }
+
+// Equals returns true if the two ContractMetadataKey instances are equal, false otherwise.
+func (c contractMetadataKey) Equals(other ContractMetadataKey) bool {
+	return c.chainSelector == other.ChainSelector() &&
+		c.address == other.Address()
+}
+
+// NewContractMetadataKey creates a new ContractMetadataKey instance.
+func NewContractMetadataKey(chainSelector uint64, address string) ContractMetadataKey {
+	return contractMetadataKey{
+		chainSelector: chainSelector,
+		address:       address,
+	}
+}

deployment/datastore/contract_metadata_key_test.go

@@ -0,0 +1,57 @@
+package datastore
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestContractMetadataKey_Equals(t *testing.T) {
+	tests := []struct {
+		name     string
+		key1     ContractMetadataKey
+		key2     ContractMetadataKey
+		expected bool
+	}{
+		{
+			name:     "Equal keys",
+			key1:     NewContractMetadataKey(1, "0x1234567890abcdef"),
+			key2:     NewContractMetadataKey(1, "0x1234567890abcdef"),
+			expected: true,
+		},
+		{
+			name:     "Different chain selector",
+			key1:     NewContractMetadataKey(1, "0x1234567890abcdef"),
+			key2:     NewContractMetadataKey(2, "0x1234567890abcdef"),
+			expected: false,
+		},
+		{
+			name:     "Different address",
+			key1:     NewContractMetadataKey(1, "0x1234567890abcdef"),
+			key2:     NewContractMetadataKey(1, "0xabcdef1234567890"),
+			expected: false,
+		},
+		{
+			name:     "Completely different keys",
+			key1:     NewContractMetadataKey(1, "0x1234567890abcdef"),
+			key2:     NewContractMetadataKey(2, "0xabcdef1234567890"),
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.expected, tt.key1.Equals(tt.key2))
+		})
+	}
+}
+
+func TestContractMetadataKey(t *testing.T) {
+	chainSelector := uint64(1)
+	address := "0x1234567890abcdef"
+
+	key := NewContractMetadataKey(chainSelector, address)
+
+	require.Equal(t, chainSelector, key.ChainSelector(), "ChainSelector should return the correct chain selector")
+	require.Equal(t, address, key.Address(), "Address should return the correct address")
+}

deployment/datastore/contract_metadata_test.go

@@ -0,0 +1,43 @@
+package datastore
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestContractMetadata_Clone(t *testing.T) {
+	original := ContractMetadata[DefaultMetadata]{
+		ChainSelector: 1,
+		Address:       "0x123",
+		Metadata:      DefaultMetadata("test data"),
+	}
+
+	cloned := original.Clone()
+
+	assert.Equal(t, original.ChainSelector, cloned.ChainSelector)
+	assert.Equal(t, original.Address, cloned.Address)
+	assert.Equal(t, original.Metadata, cloned.Metadata)
+
+	// Modify the original and ensure the cloned remains unchanged
+	original.ChainSelector = 2
+	original.Address = "0x456"
+	original.Metadata = DefaultMetadata("updated data")
+
+	assert.NotEqual(t, original.ChainSelector, cloned.ChainSelector)
+	assert.NotEqual(t, original.Address, cloned.Address)
+	assert.NotEqual(t, original.Metadata, cloned.Metadata)
+}
+
+func TestContractMetadata_Key(t *testing.T) {
+	metadata := ContractMetadata[DefaultMetadata]{
+		ChainSelector: 1,
+		Address:       "0x123",
+		Metadata:      DefaultMetadata("test data"),
+	}
+
+	key := metadata.Key()
+	expectedKey := NewContractMetadataKey(1, "0x123")
+
+	assert.Equal(t, expectedKey, key)
+}

deployment/datastore/filters.go

@@ -65,3 +65,16 @@ func AddressRefByQualifier(qualifier string) FilterFunc[AddressRefKey, AddressRe
 		return record.Qualifier == qualifier
 	})
 }
+
+// ContractMetadataByChainSelector returns a filter that only includes records with the provided chain.
+func ContractMetadataByChainSelector[M Cloneable[M]](chainSelector uint64) FilterFunc[ContractMetadataKey, ContractMetadata[M]] {
+	return func(records []ContractMetadata[M]) []ContractMetadata[M] {
+		filtered := make([]ContractMetadata[M], 0, len(records)) // Pre-allocate capacity
+		for _, record := range records {
+			if record.ChainSelector == chainSelector {
+				filtered = append(filtered, record)
+			}
+		}
+		return filtered
+	}
+}

deployment/datastore/filters_test.go

@@ -253,3 +253,59 @@ func TestAddressRefByQualifier(t *testing.T) {
 		})
 	}
 }
+
+func TestContractMetadataByChainSelector(t *testing.T) {
+	var (
+		recordOne = ContractMetadata[DefaultMetadata]{
+			ChainSelector: 1,
+			Metadata:      DefaultMetadata("Record1"),
+		}
+		recordTwo = ContractMetadata[DefaultMetadata]{
+			ChainSelector: 2,
+			Metadata:      DefaultMetadata("Record2"),
+		}
+		recordThree = ContractMetadata[DefaultMetadata]{
+			ChainSelector: 1,
+			Metadata:      DefaultMetadata("Record3"),
+		}
+	)
+
+	tests := []struct {
+		name           string
+		givenState     []ContractMetadata[DefaultMetadata]
+		giveChain      uint64
+		expectedResult []ContractMetadata[DefaultMetadata]
+	}{
+		{
+			name: "success: returns records with given chain",
+			givenState: []ContractMetadata[DefaultMetadata]{
+				recordOne,
+				recordTwo,
+				recordThree,
+			},
+			giveChain: 1,
+			expectedResult: []ContractMetadata[DefaultMetadata]{
+				recordOne,
+				recordThree,
+			},
+		},
+		{
+			name: "success: returns no records with given chain",
+			givenState: []ContractMetadata[DefaultMetadata]{
+				recordOne,
+				recordTwo,
+				recordThree,
+			},
+			giveChain:      3,
+			expectedResult: []ContractMetadata[DefaultMetadata]{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			filter := ContractMetadataByChainSelector[DefaultMetadata](tt.giveChain)
+			filteredRecords := filter(tt.givenState)
+			assert.Equal(t, tt.expectedResult, filteredRecords)
+		})
+	}
+}