asset: add Specifier.Equal method

To make sure we can compare two asset specifiers, we add a new Equal
method that returns true if two specifiers are the same.
The strictness can be chosen with the strict boolean argument. If it is
set, then both specifiers need to either have both equal asset IDs and
group keys set or only one of those (but matching).
If strict is false, then it's enough to have the same group key _or_ the
same asset ID (if one has no group key set).

Author: guggero

asset/asset.go

@@ -604,6 +604,85 @@ func (s *Specifier) AssertNotEmpty() error {
 	return nil
 }
 
+// Equal compares this specifier to another one, returning true if they are
+// equal. If strict is true, then both specifiers need to either have both equal
+// asset IDs and group keys set or only one of those (but matching). If strict
+// is false, then it's enough to have the same group key _or_ the same asset ID
+// (if one has no group key set). This is useful for cases where one specifier
+// only specifies the group key, while the other one specifies both the group
+// key and the asset ID. In that case, we can consider them equal if the group
+// keys match, even if the asset IDs are different (or one is not set).
+func (s *Specifier) Equal(other *Specifier, strict bool) (bool, error) {
+	// If both specifiers are nil, they are equal.
+	if s == nil && other == nil {
+		return true, nil
+	}
+
+	// If one of the specifiers is nil, they are not equal.
+	if s == nil || other == nil {
+		return false, nil
+	}
+
+	// If either of them is empty while the other is not, they are not
+	// equal.
+	if (s.HasId() || s.HasGroupPubKey()) !=
+		(other.HasId() || other.HasGroupPubKey()) {
+
+		return false, nil
+	}
+
+	// If they both have distinct elements set, then they are not equal.
+	if s.HasId() != other.HasId() &&
+		s.HasGroupPubKey() != other.HasGroupPubKey() {
+
+		return false, nil
+	}
+
+	// If both specifiers have a group public key, compare them.
+	if s.HasGroupPubKey() && other.HasGroupPubKey() {
+		groupKeyA := s.UnwrapGroupKeyToPtr()
+		groupKeyB := other.UnwrapGroupKeyToPtr()
+
+		// If any unwrapped element is nil, something's wrong, and we
+		// can't compare them.
+		if groupKeyA == nil || groupKeyB == nil {
+			return false, fmt.Errorf("unable to unwrap group key "+
+				"from specifier: %v vs %v", s, other)
+		}
+
+		if !groupKeyA.IsEqual(groupKeyB) {
+			return false, nil
+		}
+
+		// If we're not doing a strict comparison, then we can return
+		// true here if the group keys match. The group key has higher
+		// priority than the ID, so if they match and the comparison
+		// isn't strict, we can consider the specifiers equal.
+		if !strict {
+			return true, nil
+		}
+	}
+
+	// If both specifiers have an ID, compare them.
+	if s.HasId() && other.HasId() {
+		idA := s.UnwrapIdToPtr()
+		idB := other.UnwrapIdToPtr()
+
+		// If any unwrapped element is nil, something's wrong and we
+		// can't compare them.
+		if idA == nil || idB == nil {
+			return false, fmt.Errorf("unable to unwrap asset ID "+
+				"from specifier: %v vs %v", s, other)
+		}
+
+		if *idA != *idB {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
 // Type denotes the asset types supported by the Taproot Asset protocol.
 type Type uint8
 

asset/asset_test.go

@@ -1247,3 +1247,125 @@ func TestDecodeAsset(t *testing.T) {
 
 	t.Logf("Decoded asset: %v", string(assetJSON))
 }
+
+// TestSpecifierEqual tests the Specifier.Equal method for all possible cases.
+func TestSpecifierEqual(t *testing.T) {
+	id1 := ID{1, 2, 3}
+	id2 := ID{4, 5, 6}
+	pk1, _ := btcec.NewPrivateKey()
+	pubKey1 := pk1.PubKey()
+	pk2, _ := btcec.NewPrivateKey()
+	pubKey2 := pk2.PubKey()
+
+	cases := []struct {
+		name      string
+		s, other  *Specifier
+		strict    bool
+		expects   bool
+		expectErr bool
+	}{
+		{
+			name:    "both nil",
+			s:       nil,
+			other:   nil,
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "one nil (s)",
+			s:       nil,
+			other:   &Specifier{},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "one nil (other)",
+			s:       &Specifier{},
+			other:   nil,
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both empty",
+			s:       &Specifier{},
+			other:   &Specifier{},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with same ID",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id1)},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with different ID",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id2)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both with same group key",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with different group key",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey2)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "one with ID, one with group key",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both with ID, strict true",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id1)},
+			strict:  true,
+			expects: true,
+		},
+		{
+			name:    "both with group key, strict true",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  true,
+			expects: true,
+		},
+		{
+			name:    "one with ID, one with group key, strict true",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  true,
+			expects: false,
+		},
+		{
+			name:    "both empty, strict true",
+			s:       &Specifier{},
+			other:   &Specifier{},
+			strict:  true,
+			expects: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			eq, err := tc.s.Equal(tc.other, tc.strict)
+			if tc.expectErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expects, eq)
+			}
+		})
+	}
+}