single commit to bundle changes. draft

Author: darioAnongba

itest/test_list_on_test.go

@@ -167,6 +167,10 @@ var allTestCases = []*testCase{
 		name: "full value send",
 		test: testFullValueSend,
 	},
+	{
+		name: "zero value anchor sweep",
+		test: testZeroValueAnchorSweep,
+	},
 	{
 		name:             "collectible send hashmail courier",
 		test:             testCollectibleSend,

itest/zero_value_anchor_test.go

@@ -0,0 +1,81 @@
+//go:build itest
+
+package itest
+
+import (
+	"context"
+
+	"github.com/lightninglabs/taproot-assets/itest/rpcassert"
+	"github.com/lightninglabs/taproot-assets/taprpc"
+	mintrpc "github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
+	"github.com/stretchr/testify/require"
+)
+
+func testZeroValueAnchorSweep(t *harnessTest) {
+	t.t.Helper()
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
+	defer cancel()
+
+	miner := t.lndHarness.Miner().Client
+
+	firstMint := MintAssetsConfirmBatch(
+		t.t, miner, t.tapd, []*mintrpc.MintAssetRequest{CopyRequest(simpleAssets[0])},
+	)
+
+	bobLnd := t.lndHarness.NewNodeWithCoins("bob-zero-anchor", nil)
+	bobTapd := setupTapdHarness(t.t, t, bobLnd, t.universeServer)
+	defer func() {
+		require.NoError(t.t, bobTapd.stop(!*noDelete))
+		bobLnd.Cleanup(nil)
+	}()
+
+	recvAddr := rpcassert.NewAddrRPC(t.t, ctxt, bobTapd, nil, &taprpc.NewAddrRequest{
+		AssetId:      firstMint[0].AssetGenesis.AssetId,
+		Amt:          firstMint[0].Amount,
+		AssetVersion: firstMint[0].Version,
+	})
+
+	sendResp1, sendEvents1 := sendAsset(
+		t, t.tapd, withReceiverAddresses(recvAddr), withSkipProofCourierPingCheck(),
+	)
+	defer sendEvents1.Cancel()
+
+	var tombstoneOutpoint string
+	for _, out := range sendResp1.Transfer.Outputs {
+		// We don't require ScriptKeyIsLocal on tombstones (NUMS key is not
+		// controlled by us). We only check for zero-amount, split-root type.
+		if out.Amount == 0 {
+			tombstoneOutpoint = out.Anchor.Outpoint
+			break
+		}
+	}
+	require.NotEmpty(t.t, tombstoneOutpoint, "expected tombstone output not found")
+
+	MineBlocks(t.t, miner, 1, 1)
+
+	secondMint := MintAssetsConfirmBatch(
+		t.t, miner, t.tapd, []*mintrpc.MintAssetRequest{CopyRequest(simpleAssets[0])},
+	)
+
+	recvAddr2 := rpcassert.NewAddrRPC(t.t, ctxt, bobTapd, nil, &taprpc.NewAddrRequest{
+		AssetId:      secondMint[0].AssetGenesis.AssetId,
+		Amt:          secondMint[0].Amount,
+		AssetVersion: secondMint[0].Version,
+	})
+
+	sendResp2, sendEvents2 := sendAsset(
+		t, t.tapd, withReceiverAddresses(recvAddr2), withSkipProofCourierPingCheck(),
+	)
+	defer sendEvents2.Cancel()
+
+	found := false
+	for _, in := range sendResp2.Transfer.Inputs {
+		if in.AnchorPoint == tombstoneOutpoint {
+			found = true
+			break
+		}
+	}
+	require.Truef(t.t, found, "zero value anchor %v not swept", tombstoneOutpoint)
+}

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,93 @@ 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.
+// ListZeroValueAnchors implements both the tapfreighter and tapgarden lister
+// flavors by returning tapfreighter.ZeroValueAnchor; tapgarden wraps it via a
+// thin adapter in planter.
+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)
+		var (
+			anchorCommitment *commitment.TapCommitment
+			assets           []*asset.Asset
+		)
+
+		switch {
+		case errors.Is(err, tapfreighter.ErrMatchingAssetsNotFound):
+			// No spendable assets anchored here, which is exactly the
+			// situation we want to sweep.
+		case err != nil:
+			return nil, err
+		default:
+			if len(commitments) > 0 {
+				anchorCommitment = commitments[0].Commitment
+				assets = anchorCommitment.CommittedAssets()
+			}
+		}
+
+		zeroValue := len(assets) == 0
+		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,
+			TaprootAssetRoot: append([]byte(nil), utxo.TaprootAssetRoot...),
+			MerkleRoot:       append([]byte(nil), utxo.MerkleRoot...),
+			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 +2563,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

@@ -1245,15 +1245,16 @@ func (p *ChainPorter) importLocalAddresses(ctx context.Context,
 
 	// We'll need to extract the output public key from the tx out that does
 	// the send. We'll use this shortly below as a step before broadcast.
+	//
+	// For outbound parcels, we always control the anchor output internal
+	// keys, regardless of whether the asset script key is local or not.
+	// This includes tombstone outputs (which use NUMS script keys but have
+	// local anchor internal keys). We need to import all these anchor
+	// outputs into lnd's wallet so they can be spent later (e.g., for
+	// sweeping zero-value anchors).
 	for idx := range parcel.Outputs {
 		out := &parcel.Outputs[idx]
 
-		// Skip non-local outputs, those are going to a receiver outside
-		// of this daemon.
-		if !out.ScriptKeyLocal {
-			continue
-		}
-
 		anchorOutputIndex := out.Anchor.OutPoint.Index
 		anchorOutput := parcel.AnchorTx.TxOut[anchorOutputIndex]
 		_, witProgram, err := txscript.ExtractWitnessProgramInfo(
@@ -1589,7 +1590,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 +1609,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
@@ -1655,6 +1657,13 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		// local means the lnd node connected to this daemon knows how
 		// to derive the key.
 		isLocalKey := func(key asset.ScriptKey) (bool, error) {
+			// Tombstone outputs use the NUMS key and are always controlled by
+			// the local daemon so we treat them as local regardless of whether
+			// the key was explicitly declared before.
+			if key.PubKey != nil && key.PubKey.IsEqual(asset.NUMSPubKey) {
+				return true, nil
+			}
+
 			// To make sure we have the correct internal key with
 			// the family and index set, we attempt to fetch it
 			// from the database. If it exists, then we know we
@@ -1695,7 +1704,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,44 @@ 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 if one can be reconstructed from the asset data stored on
+	// disk. For anchors that only contain tombstones/burns, this might be
+	// nil.
+	Commitment *commitment.TapCommitment
+
+	// TaprootAssetRoot is the Taproot Asset commitment root hash committed
+	// to by this outpoint.
+	TaprootAssetRoot []byte
+
+	// MerkleRoot is the tapscript merkle root that includes the Taproot
+	// Asset commitment and an optional sibling.
+	MerkleRoot []byte
+
+	// 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 +511,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 +546,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,
 	}