single commit to bundle changes. draft

Author: darioAnongba

tapcfg/server.go

@@ -425,6 +425,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 		GroupVerifier:    groupVerifier,
 		IgnoreChecker:    ignoreCheckerOpt,
 		Wallet:           walletAnchor,
+		AnchorLister:     assetStore,
 		ChainParams:      &tapChainParams,
 	})
 

tapdb/assets_store.go

@@ -1320,6 +1320,87 @@ func (a *AssetStore) FetchManagedUTXOs(ctx context.Context) (
 	return managedUtxos, nil
 }
 
+// ListZeroValueAnchors returns the set of managed anchor UTXOs that only
+// contain tombstone/burn commitments and therefore have zero effective asset
+// value.
+//
+// NOTE: This implements the tapfreighter.ZeroValueAnchorLister interface.
+func (a *AssetStore) ListZeroValueAnchors(ctx context.Context) (
+	[]*tapfreighter.ZeroValueAnchor, error) {
+
+	managedUtxos, err := a.FetchManagedUTXOs(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	now := a.clock.Now().UTC()
+	anchors := make([]*tapfreighter.ZeroValueAnchor, 0)
+
+	for _, utxo := range managedUtxos {
+		// Skip entries that are currently leased.
+		if len(utxo.LeaseOwner) != 0 {
+			if utxo.LeaseExpiry.IsZero() || !utxo.LeaseExpiry.Before(now) {
+				continue
+			}
+		}
+
+		anchorPointBytes, err := encodeOutpoint(utxo.OutPoint)
+		if err != nil {
+			return nil, err
+		}
+
+		filter := QueryAssetFilters{
+			AnchorPoint: anchorPointBytes,
+			Spent:       sqlBool(false),
+			Leased:      sqlBool(false),
+			Now: sql.NullTime{
+				Time:  now,
+				Valid: true,
+			},
+		}
+
+		commitments, err := a.queryCommitments(ctx, filter)
+		switch {
+		case errors.Is(err, tapfreighter.ErrMatchingAssetsNotFound):
+			continue
+		case err != nil:
+			return nil, err
+		}
+
+		if len(commitments) == 0 {
+			continue
+		}
+
+		anchorCommitment := commitments[0].Commitment
+		assets := anchorCommitment.CommittedAssets()
+		if len(assets) == 0 {
+			continue
+		}
+
+		zeroValue := true
+		for _, asset := range assets {
+			if asset.Amount > 0 && !asset.IsBurn() {
+				zeroValue = false
+				break
+			}
+		}
+
+		if !zeroValue {
+			continue
+		}
+
+		anchors = append(anchors, &tapfreighter.ZeroValueAnchor{
+			OutPoint:         utxo.OutPoint,
+			Value:            utxo.OutputValue,
+			InternalKey:      utxo.InternalKey,
+			Commitment:       anchorCommitment,
+			TapscriptSibling: append([]byte(nil), utxo.TapscriptSibling...),
+		})
+	}
+
+	return anchors, nil
+}
+
 // FetchAssetProofsSizes fetches the sizes of the proofs in the db.
 func (a *AssetStore) FetchAssetProofsSizes(
 	ctx context.Context) ([]AssetProofSize, error) {
@@ -2476,6 +2557,26 @@ func (a *AssetStore) LogPendingParcel(ctx context.Context,
 			}
 		}
 
+		for _, zeroAnchor := range spend.ZeroValueAnchors {
+			anchorPointBytes, err := encodeOutpoint(zeroAnchor)
+			if err != nil {
+				return err
+			}
+
+			err = q.UpdateUTXOLease(ctx, UpdateUTXOLease{
+				LeaseOwner: finalLeaseOwner[:],
+				LeaseExpiry: sql.NullTime{
+					Time:  finalLeaseExpiry.UTC(),
+					Valid: true,
+				},
+				Outpoint: anchorPointBytes,
+			})
+			if err != nil {
+				return fmt.Errorf("unable to lease zero value "+
+					"anchor: %w", err)
+			}
+		}
+
 		// Then the passive assets.
 		if len(spend.PassiveAssets) > 0 {
 			if spend.PassiveAssetsAnchor == nil {

tapfreighter/chain_porter.go

@@ -1589,7 +1589,7 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 				"assets: %w", err)
 		}
 
-		anchorTx, err := wallet.AnchorVirtualTransactions(
+		anchorTx, sweptAnchors, err := wallet.AnchorVirtualTransactions(
 			ctx, &AnchorVTxnsParams{
 				FeeRate:        feeRate,
 				ActivePackets:  currentPkg.VirtualPackets,
@@ -1608,6 +1608,7 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		// signing process with a copy to avoid clearing the info on
 		// finalization.
 		currentPkg.AnchorTx = anchorTx
+		currentPkg.ZeroValueAnchors = sweptAnchors
 
 		// For the final validation, we need to also supply the assets
 		// that were committed to the input tree but pruned because they
@@ -1695,7 +1696,7 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		parcel, err := ConvertToTransfer(
 			currentHeight, currentPkg.VirtualPackets,
 			currentPkg.AnchorTx, currentPkg.PassiveAssets,
-			isLocalKey, currentPkg.Label,
+			currentPkg.ZeroValueAnchors, isLocalKey, currentPkg.Label,
 			currentPkg.SkipAnchorTxBroadcast,
 		)
 		if err != nil {

tapfreighter/interface.go

@@ -192,6 +192,12 @@ type CoinSelector interface {
 		maxVersion commitment.TapCommitmentVersion,
 	) ([]*AnchoredCommitment, error)
 
+	// LeaseCoins leases/locks/reserves coins for the given lease owner
+	// until the given expiry. This is used to prevent multiple concurrent
+	// coin selection attempts from selecting the same coin(s).
+	LeaseCoins(ctx context.Context, leaseOwner [32]byte, expiry time.Time,
+		utxoOutpoints ...wire.OutPoint) error
+
 	// ReleaseCoins releases/unlocks coins that were previously leased and
 	// makes them available for coin selection again.
 	ReleaseCoins(ctx context.Context, utxoOutpoints ...wire.OutPoint) error
@@ -244,6 +250,34 @@ type Anchor struct {
 	PkScript []byte
 }
 
+// ZeroValueAnchor describes a managed anchor UTXO whose commitment only holds
+// tombstones/burns and therefore carries zero effective asset value.
+type ZeroValueAnchor struct {
+	// OutPoint is the BTC outpoint of the anchor UTXO.
+	OutPoint wire.OutPoint
+
+	// Value is the BTC value locked in the anchor output.
+	Value btcutil.Amount
+
+	// InternalKey is the internal key that anchors the commitment in the
+	// outpoint.
+	InternalKey keychain.KeyDescriptor
+
+	// Commitment is the full Taproot Asset commitment anchored at the
+	// outpoint.
+	Commitment *commitment.TapCommitment
+
+	// TapscriptSibling is the serialized tapscript sibling preimage for the
+	// anchor output (if present).
+	TapscriptSibling []byte
+}
+
+// ZeroValueAnchorLister lists managed anchor UTXOs whose asset commitments
+// carry no spendable value.
+type ZeroValueAnchorLister interface {
+	ListZeroValueAnchors(ctx context.Context) ([]*ZeroValueAnchor, error)
+}
+
 // OutputIdentifier is a key that can be used to uniquely identify a transfer
 // output.
 type OutputIdentifier [32]byte
@@ -467,6 +501,10 @@ type OutboundParcel struct {
 	// during the parcel confirmation process.
 	PassiveAssets []*tappsbt.VPacket
 
+	// ZeroValueAnchors lists the tombstone/burn anchors that were swept as
+	// additional BTC inputs when constructing the anchor transaction.
+	ZeroValueAnchors []wire.OutPoint
+
 	// PassiveAssetsAnchor is the anchor point for the passive assets. This
 	// might be a distinct anchor from any active transfer in case the
 	// active transfers don't create any change going back to us.
@@ -498,6 +536,7 @@ func (o *OutboundParcel) Copy() *OutboundParcel {
 		ChainFees:             o.ChainFees,
 		Inputs:                fn.CopySlice(o.Inputs),
 		Outputs:               fn.CopySlice(o.Outputs),
+		ZeroValueAnchors:      fn.CopySlice(o.ZeroValueAnchors),
 		Label:                 o.Label,
 		SkipAnchorTxBroadcast: o.SkipAnchorTxBroadcast,
 	}

tapfreighter/parcel.go

@@ -494,6 +494,10 @@ type sendPackage struct {
 	// PassiveAssets is the data used in re-anchoring passive assets.
 	PassiveAssets []*tappsbt.VPacket
 
+	// ZeroValueAnchors keeps track of tombstone/burn anchors that were added
+	// as extra BTC inputs to the anchor transaction for garbage collection.
+	ZeroValueAnchors []wire.OutPoint
+
 	// Parcel is the asset transfer request that kicked off this transfer.
 	Parcel Parcel
 
@@ -546,6 +550,7 @@ type sendPackage struct {
 // they were already committed at.
 func ConvertToTransfer(currentHeight uint32, activeTransfers []*tappsbt.VPacket,
 	anchorTx *tapsend.AnchorTransaction, passiveAssets []*tappsbt.VPacket,
+	zeroValueAnchors []wire.OutPoint,
 	isLocalKey func(asset.ScriptKey) (bool, error), label string,
 	skipAnchorTxBroadcast bool) (*OutboundParcel, error) {
 
@@ -584,6 +589,7 @@ func ConvertToTransfer(currentHeight uint32, activeTransfers []*tappsbt.VPacket,
 		),
 		PassiveAssets:         passiveAssets,
 		PassiveAssetsAnchor:   passiveAssetAnchor,
+		ZeroValueAnchors:      fn.CopySlice(zeroValueAnchors),
 		Label:                 label,
 		SkipAnchorTxBroadcast: skipAnchorTxBroadcast,
 	}