multi: hook up burn and mint events to the supply commit state machine

address/book.go

@@ -28,6 +28,18 @@ var (
 	// ErrAssetMetaNotFound is returned when an asset meta is not found in
 	// the database.
 	ErrAssetMetaNotFound = fmt.Errorf("asset meta not found")
+
+	// ErrAssetGroupQueryFailed is returned when querying for an asset group
+	// fails.
+	ErrAssetGroupQueryFailed = fmt.Errorf("asset group query failed")
+
+	// ErrAssetMetaQueryFailed is returned when querying for asset metadata
+	// fails.
+	ErrAssetMetaQueryFailed = fmt.Errorf("asset meta query failed")
+
+	// ErrDelegationKeyQueryFailed is returned when querying for delegation
+	// key fails.
+	ErrDelegationKeyQueryFailed = fmt.Errorf("delegation key query failed")
 )
 
 // AddrWithKeyInfo wraps a normal Taproot Asset struct with key descriptor
@@ -165,6 +177,12 @@ type Storage interface {
 	// database.
 	FetchAllAssetMeta(
 		ctx context.Context) (map[asset.ID]*proof.MetaReveal, error)
+
+	// FetchInternalKeyLocator attempts to fetch the key locator information
+	// for the given raw internal key. If the key cannot be found, then
+	// ErrInternalKeyNotFound is returned.
+	FetchInternalKeyLocator(ctx context.Context,
+		rawKey *btcec.PublicKey) (keychain.KeyLocator, error)
 }
 
 // KeyRing is used to create script and internal keys for Taproot Asset
@@ -841,3 +859,73 @@ func (b *Book) RemoveSubscriber(
 
 	return nil
 }
+
+// DelegationKeyChecker is used to verify that we control the delegation key
+// for a given asset, which is required for creating supply commitments.
+type DelegationKeyChecker interface {
+	// HasDelegationKey checks if we control the delegation key for the
+	// given asset ID. Returns true if we have the private key for the
+	// asset's delegation key, false otherwise.
+	HasDelegationKey(ctx context.Context, assetID asset.ID) (bool, error)
+}
+
+// HasDelegationKey checks if we control the delegation key for the given
+// asset ID. Returns true if we have the private key for the asset's
+// delegation key, false otherwise.
+//
+// NOTE: This is part of the DelegationKeyChecker interface.
+func (b *Book) HasDelegationKey(ctx context.Context,
+	assetID asset.ID) (bool, error) {
+
+	assetGroup, err := b.cfg.Store.QueryAssetGroupByID(ctx, assetID)
+	if err != nil {
+		return false, fmt.Errorf("%w: %w", ErrAssetGroupQueryFailed,
+			err)
+	}
+
+	// If the asset doesn't have a group, it can't have a delegation key. So
+	// we just return false here.
+	if assetGroup == nil || assetGroup.GroupKey == nil {
+		return false, nil
+	}
+
+	// Retrieve asset meta reveal for the asset ID. This will be used to
+	// obtain the supply commitment delegation key.
+	metaReveal, err := b.cfg.Store.FetchAssetMetaForAsset(ctx, assetID)
+	if err != nil {
+		return false, fmt.Errorf("%w: %w", ErrAssetMetaQueryFailed, err)
+	}
+
+	// If there's no meta reveal or delegation key, we can't control it.
+	if metaReveal == nil || metaReveal.DelegationKey.IsNone() {
+		return false, nil
+	}
+
+	delegationPubKey, err := metaReveal.DelegationKey.UnwrapOrErr(
+		fmt.Errorf("delegation key not found for given asset"),
+	)
+	if err != nil {
+		return false, err
+	}
+
+	// Now that we have the delegation key, we'll see if we know of the
+	// internal key locator. If we do, then this means that we were the ones
+	// that created it in the first place.
+	_, err = b.cfg.Store.FetchInternalKeyLocator(ctx, &delegationPubKey)
+	switch {
+	// If we get this error, then we don't control this delegation key.
+	case errors.Is(err, ErrInternalKeyNotFound):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("%w: %w",
+			ErrDelegationKeyQueryFailed, err)
+	}
+
+	// If we reached this point, then we know that we control the delegation
+	// key.
+	return true, nil
+}
+
+// A compile-time assertion to ensure Book implements the DelegationKeyChecker
+// interface.
+var _ DelegationKeyChecker = (*Book)(nil)