fix: simplify datastore query logic with existing cldf helpers

Author: ecPablo

mcms/changesets/set-config/changeset_test.go

@@ -416,18 +416,20 @@ func TestChangeset_EVM_Qualifier(t *testing.T) {
 			name:      "missing qualifier",
 			qualifier: "",
 			wantErr: fmt.Sprintf(
-				"validate timelock ref for chain %s: no addresses found for chain %s",
+				"validate timelock ref for chain %s: multiple address refs matched query: expected exactly 1 ref matching query {ChainSelector: %s, Type: %s}, found 2",
 				selectorStr,
 				selectorStr,
+				mcmscontracts.RBACTimelock,
 			),
 		},
 		{
 			name:      "unknown qualifier",
 			qualifier: "does-not-exist",
 			wantErr: fmt.Sprintf(
-				"validate timelock ref for chain %s: no addresses found for chain %s with qualifier \"does-not-exist\"",
+				"validate timelock ref for chain %s: no address ref matched query: expected exactly 1 ref matching query {ChainSelector: %s, Type: %s, Qualifier: does-not-exist}, found 0",
 				selectorStr,
 				selectorStr,
+				mcmscontracts.RBACTimelock,
 			),
 		},
 	} {

mcms/evm/readers/reader.go

@@ -66,31 +66,11 @@ func evmAddressRef(e cldf.Environment, chainSelector uint64, contractType cldf.C
 		return datastore.AddressRef{}, fmt.Errorf("datastore not available for chain %d", chainSelector)
 	}
 
-	filters := []datastore.FilterFunc[datastore.AddressRefKey, datastore.AddressRef]{
-		datastore.AddressRefByChainSelector(chainSelector),
-		datastore.AddressRefByType(datastore.ContractType(contractType)),
-		datastore.AddressRefByQualifier(qualifier),
-	}
-
-	refs := e.DataStore.Addresses().Filter(filters...)
-	if len(refs) == 0 {
-		if qualifier != "" {
-			return datastore.AddressRef{}, fmt.Errorf("no addresses found for chain %d with qualifier %q", chainSelector, qualifier)
-		}
-
-		return datastore.AddressRef{}, fmt.Errorf("no addresses found for chain %d", chainSelector)
-	}
-	if len(refs) > 1 {
-		ref := refs[0]
-		return datastore.AddressRef{}, fmt.Errorf(
-			"found more than one instance of contract %s v%s (labels=%s)",
-			contractType,
-			ref.Version.String(),
-			ref.Labels.String(),
-		)
-	}
-
-	return refs[0], nil
+	return datastore.FindUniqueRef(e.DataStore.Addresses(), datastore.AddressRef{
+		ChainSelector: chainSelector,
+		Type:          datastore.ContractType(contractType),
+		Qualifier:     qualifier,
+	})
 }
 
 func evmMCMSRef(e cldf.Environment, chainSelector uint64, input cldf.MCMSTimelockProposalInput) (datastore.AddressRef, error) {

mcms/evm/readers/reader_test.go

@@ -38,14 +38,6 @@ func TestReaderGetRefs(t *testing.T) {
 			Version:       version,
 		}))
 	}
-	require.NoError(t, ds.Addresses().Add(datastore.AddressRef{
-		Address:       "0x0000000000000000000000000000000000000aaa",
-		ChainSelector: selector,
-		Type:          datastore.ContractType(mcmscontracts.ProposerManyChainMultisig),
-		Version:       version,
-		Qualifier:     "qualified",
-	}))
-
 	env := readerTestEnv(ds.Seal())
 	reader := Reader{}
 
@@ -75,9 +67,30 @@ func TestReaderGetRefs(t *testing.T) {
 		})
 	}
 
-	gotQualified, err := reader.GetMCMSRef(env, selector, cldf.MCMSTimelockProposalInput{Qualifier: "qualified"})
-	require.NoError(t, err)
-	require.Equal(t, "0x0000000000000000000000000000000000000aaa", gotQualified.Address)
+	t.Run("qualified proposer", func(t *testing.T) {
+		t.Parallel()
+
+		qualifiedDS := datastore.NewMemoryDataStore()
+		for typ, address := range refs {
+			require.NoError(t, qualifiedDS.Addresses().Add(datastore.AddressRef{
+				Address:       address,
+				ChainSelector: selector,
+				Type:          typ,
+				Version:       version,
+			}))
+		}
+		require.NoError(t, qualifiedDS.Addresses().Add(datastore.AddressRef{
+			Address:       "0x0000000000000000000000000000000000000aaa",
+			ChainSelector: selector,
+			Type:          datastore.ContractType(mcmscontracts.ProposerManyChainMultisig),
+			Version:       version,
+			Qualifier:     "qualified",
+		}))
+
+		gotQualified, refErr := reader.GetMCMSRef(readerTestEnv(qualifiedDS.Seal()), selector, cldf.MCMSTimelockProposalInput{Qualifier: "qualified"})
+		require.NoError(t, refErr)
+		require.Equal(t, "0x0000000000000000000000000000000000000aaa", gotQualified.Address)
+	})
 }
 
 func TestReaderErrors(t *testing.T) {
@@ -96,7 +109,8 @@ func TestReaderErrors(t *testing.T) {
 	_, err = reader.GetMCMSRef(readerTestEnv(datastore.NewMemoryDataStore().Seal()), 1, cldf.MCMSTimelockProposalInput{
 		Qualifier: "missing",
 	})
-	require.EqualError(t, err, `no addresses found for chain 1 with qualifier "missing"`)
+	require.ErrorContains(t, err, "no address ref matched query")
+	require.ErrorContains(t, err, "Qualifier: missing")
 }
 
 func readerTestEnv(ds datastore.DataStore) cldf.Environment {

mcms/solana/readers/reader.go

@@ -104,31 +104,11 @@ func solanaAddressRef(e cldf.Environment, chainSelector uint64, contractType cld
 		return datastore.AddressRef{}, fmt.Errorf("datastore not available for chain %d", chainSelector)
 	}
 
-	filters := []datastore.FilterFunc[datastore.AddressRefKey, datastore.AddressRef]{
-		datastore.AddressRefByChainSelector(chainSelector),
-		datastore.AddressRefByType(datastore.ContractType(contractType)),
-		datastore.AddressRefByQualifier(qualifier),
-	}
-
-	refs := e.DataStore.Addresses().Filter(filters...)
-	if len(refs) == 0 {
-		if qualifier != "" {
-			return datastore.AddressRef{}, fmt.Errorf("no addresses found for chain %d with qualifier %q", chainSelector, qualifier)
-		}
-
-		return datastore.AddressRef{}, fmt.Errorf("no addresses found for chain %d", chainSelector)
-	}
-	if len(refs) > 1 {
-		ref := refs[0]
-		return datastore.AddressRef{}, fmt.Errorf(
-			"found more than one instance of contract %s v%s (labels=%s)",
-			contractType,
-			ref.Version.String(),
-			ref.Labels.String(),
-		)
-	}
-
-	return refs[0], nil
+	return datastore.FindUniqueRef(e.DataStore.Addresses(), datastore.AddressRef{
+		ChainSelector: chainSelector,
+		Type:          datastore.ContractType(contractType),
+		Qualifier:     qualifier,
+	})
 }
 
 func solanaMCMSRef(e cldf.Environment, chainSelector uint64, input cldf.MCMSTimelockProposalInput) (datastore.AddressRef, error) {