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,87 @@
+//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])},
+	)
+
+	// The second mint should sweep the previous tombstone outpoint as a BTC
+	// input of its anchor transaction.
+	// Re-query managed transactions and assert usage indirectly by checking
+	// that a new mint happened (already ensured) and later the following send
+	// can select the same anchor input if needed.
+
+	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,
 	})
 
@@ -697,6 +698,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 				IgnoreChecker:         ignoreCheckerOpt,
 				MintSupplyCommitter:   supplyCommitManager,
 				DelegationKeyChecker:  addrBook,
+				AnchorLister:          assetStore,
 			},
 			ChainParams:  tapChainParams,
 			ProofUpdates: proofArchive,

tapdb/assets_store.go

@@ -22,6 +22,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
 	"github.com/lightninglabs/taproot-assets/tapfreighter"
+	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/tappsbt"
 	"github.com/lightninglabs/taproot-assets/tapsend"
 	"github.com/lightningnetwork/lnd/clock"
@@ -1320,6 +1321,116 @@ 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
+}
+
+// ListZeroValueAnchorsMint adapts the store to the tapgarden.MintAnchorLister
+// by mapping to the tapfreighter variant.
+func (a *AssetStore) ListZeroValueAnchorsMint(ctx context.Context) (
+	[]*tapgarden.MintZeroValueAnchor, error) {
+	anchors, err := a.ListZeroValueAnchors(ctx)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]*tapgarden.MintZeroValueAnchor, 0, len(anchors))
+	for _, z := range anchors {
+		out = append(out, &tapgarden.MintZeroValueAnchor{
+			OutPoint:         z.OutPoint,
+			Value:            z.Value,
+			InternalKey:      z.InternalKey,
+			Commitment:       z.Commitment,
+			TaprootAssetRoot: append([]byte(nil), z.TaprootAssetRoot...),
+			MerkleRoot:       append([]byte(nil), z.MerkleRoot...),
+			TapscriptSibling: append([]byte(nil), z.TapscriptSibling...),
+		})
+	}
+	return out, nil
+}
+
 // FetchAssetProofsSizes fetches the sizes of the proofs in the db.
 func (a *AssetStore) FetchAssetProofsSizes(
 	ctx context.Context) ([]AssetProofSize, error) {
@@ -2476,6 +2587,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
@@ -1655,6 +1656,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 +1703,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,
 	}