tapfreighter: add call to FetchZeroValueAnchorUTXOs to retrieve zero-value inputs

Author: darioAnongba

tapfreighter/chain_porter.go

@@ -888,6 +888,7 @@ func (p *ChainPorter) storePackageAnchorTxConf(pkg *sendPackage) error {
 		TxIndex:                int32(pkg.TransferTxConfEvent.TxIndex),
 		FinalProofs:            pkg.FinalProofs,
 		PassiveAssetProofFiles: passiveAssetProofFiles,
+		ZeroValueInputs:        pkg.ZeroValueInputs,
 	}, burns)
 	if err != nil {
 		return fmt.Errorf("unable to log parcel delivery "+
@@ -1248,9 +1249,20 @@ func (p *ChainPorter) importLocalAddresses(ctx context.Context,
 	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 {
+		// Determine if the output should be imported into the wallet.
+		// We import outputs that:
+		// 1. Have local script keys (normal change outputs)
+		// 2. Tombstones (zero-value with NUMS key)
+		// 3. Burns (zero-value with burn key)
+		isTombstone := out.Amount == 0 &&
+			out.ScriptKey.PubKey.IsEqual(asset.NUMSPubKey)
+		isBurn := out.Amount == 0 && len(out.WitnessData) > 0 &&
+			asset.IsBurnKey(
+				out.ScriptKey.PubKey, out.WitnessData[0],
+			)
+		shouldImport := out.ScriptKeyLocal || isTombstone || isBurn
+
+		if !shouldImport {
 			continue
 		}
 
@@ -1266,6 +1278,10 @@ func (p *ChainPorter) importLocalAddresses(ctx context.Context,
 		if err != nil {
 			return err
 		}
+		log.Infof("Importing anchor output key for output %d "+
+			"(isTombstone=%v, isBurn=%v): outpoint=%v, key=%x",
+			idx, isTombstone, isBurn, out.Anchor.OutPoint,
+			anchorOutputKey.SerializeCompressed())
 
 		// Before we broadcast the transaction to the network, we'll
 		// import the new anchor output into the wallet so it watches
@@ -1274,13 +1290,11 @@ func (p *ChainPorter) importLocalAddresses(ctx context.Context,
 		_, err = p.cfg.Wallet.ImportTaprootOutput(ctx, anchorOutputKey)
 		switch {
 		case err == nil:
-			break
 
 		// On restart, we'll get an error that the output has already
 		// been added to the wallet, so we'll catch this now and move
 		// along if so.
 		case strings.Contains(err.Error(), "already exists"):
-			break
 
 		default:
 			return err
@@ -1446,6 +1460,7 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 
 		currentPkg.VirtualPackets = fundSendRes.VPackets
 		currentPkg.InputCommitments = fundSendRes.InputCommitments
+		currentPkg.ZeroValueInputs = fundSendRes.ZeroValueInputs
 
 		currentPkg.SendState = SendStateVirtualSign
 
@@ -1591,9 +1606,10 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 
 		anchorTx, err := wallet.AnchorVirtualTransactions(
 			ctx, &AnchorVTxnsParams{
-				FeeRate:        feeRate,
-				ActivePackets:  currentPkg.VirtualPackets,
-				PassivePackets: currentPkg.PassiveAssets,
+				FeeRate:         feeRate,
+				ActivePackets:   currentPkg.VirtualPackets,
+				PassivePackets:  currentPkg.PassiveAssets,
+				ZeroValueInputs: currentPkg.ZeroValueInputs,
 			},
 		)
 		if err != nil {

tapfreighter/coin_select.go

@@ -199,4 +199,15 @@ func (s *CoinSelect) selectForAmount(minTotalAmount uint64,
 	return selectedCommitments, nil
 }
 
+// FetchZeroValueAnchorUTXOs fetches all managed UTXOs that contain only
+// zero-value assets (tombstones and burns).
+func (s *CoinSelect) FetchZeroValueAnchorUTXOs(ctx context.Context) (
+	[]ZeroValueInput, error) {
+
+	s.coinLock.Lock()
+	defer s.coinLock.Unlock()
+
+	return s.coinLister.FetchZeroValueAnchorUTXOs(ctx)
+}
+
 var _ CoinSelector = (*CoinSelect)(nil)

tapfreighter/coin_select_test.go

@@ -60,6 +60,12 @@ func (m *mockCoinLister) DeleteExpiredLeases(ctx context.Context) error {
 	return nil
 }
 
+func (m *mockCoinLister) FetchZeroValueAnchorUTXOs(
+	context.Context) ([]ZeroValueInput, error) {
+
+	return nil, nil
+}
+
 // TestCoinSelector tests that the coin selector behaves as expected.
 func TestCoinSelector(t *testing.T) {
 	var (

tapfreighter/interface.go

@@ -168,6 +168,10 @@ type CoinLister interface {
 
 	// DeleteExpiredLeases deletes all expired leases from the database.
 	DeleteExpiredLeases(ctx context.Context) error
+
+	// FetchZeroValueAnchorUTXOs fetches all managed UTXOs that contain only
+	// zero-value assets (tombstones and burns).
+	FetchZeroValueAnchorUTXOs(ctx context.Context) ([]ZeroValueInput, error)
 }
 
 // MultiCommitmentSelectStrategy is an enum that describes the strategy that
@@ -195,6 +199,30 @@ type CoinSelector interface {
 	// ReleaseCoins releases/unlocks coins that were previously leased and
 	// makes them available for coin selection again.
 	ReleaseCoins(ctx context.Context, utxoOutpoints ...wire.OutPoint) error
+
+	// FetchZeroValueAnchorUTXOs fetches all managed UTXOs that contain only
+	// zero-value assets (tombstones and burns).
+	FetchZeroValueAnchorUTXOs(ctx context.Context) ([]ZeroValueInput, error)
+}
+
+// ZeroValueInput represents a zero-value UTXO that should be swept.
+type ZeroValueInput interface {
+	// GetOutPoint returns the outpoint of the zero-value UTXO.
+	GetOutPoint() wire.OutPoint
+
+	// GetOutputValue returns the satoshi value of the zero-value UTXO.
+	GetOutputValue() btcutil.Amount
+
+	// GetInternalKey returns the internal key descriptor for the
+	// zero-value UTXO.
+	GetInternalKey() keychain.KeyDescriptor
+
+	// GetMerkleRoot returns the taproot merkle root for the zero-value
+	// UTXO.
+	GetMerkleRoot() []byte
+
+	// GetPkScript returns the pkScript of the anchor output.
+	GetPkScript() []byte
 }
 
 // TransferInput represents the database level input to an asset transfer.
@@ -574,6 +602,10 @@ type AssetConfirmEvent struct {
 	// PassiveAssetProofFiles is the set of passive asset proof files that
 	// are re-anchored during the parcel confirmation process.
 	PassiveAssetProofFiles map[asset.ID][]*proof.AnnotatedProof
+
+	// ZeroValueInputs is the set of zero-value UTXOs that were swept as
+	// additional inputs to the Bitcoin transaction.
+	ZeroValueInputs []ZeroValueInput
 }
 
 // ExportLog is used to track the state of outbound Taproot Asset parcels

tapfreighter/parcel.go

@@ -283,6 +283,10 @@ type PreSignedParcel struct {
 	// spent in the virtual transaction.
 	inputCommitments tappsbt.InputCommitments
 
+	// zeroValueInputs is the list of zero-value UTXOs that should be swept
+	// as additional inputs to the transaction.
+	zeroValueInputs []ZeroValueInput
+
 	// note is a string that provides any user defined description for this
 	// transfer.
 	note string
@@ -295,7 +299,7 @@ var _ Parcel = (*PreSignedParcel)(nil)
 // NewPreSignedParcel creates a new PreSignedParcel.
 func NewPreSignedParcel(vPackets []*tappsbt.VPacket,
 	inputCommitments tappsbt.InputCommitments,
-	note string) *PreSignedParcel {
+	zeroValueInputs []ZeroValueInput, note string) *PreSignedParcel {
 
 	return &PreSignedParcel{
 		parcelKit: &parcelKit{
@@ -304,6 +308,7 @@ func NewPreSignedParcel(vPackets []*tappsbt.VPacket,
 		},
 		vPackets:         vPackets,
 		inputCommitments: inputCommitments,
+		zeroValueInputs:  zeroValueInputs,
 		note:             note,
 	}
 }
@@ -320,6 +325,7 @@ func (p *PreSignedParcel) pkg() *sendPackage {
 		SendState:        SendStateAnchorSign,
 		VirtualPackets:   p.vPackets,
 		InputCommitments: p.inputCommitments,
+		ZeroValueInputs:  p.zeroValueInputs,
 		Note:             p.note,
 	}
 }
@@ -486,6 +492,10 @@ type sendPackage struct {
 	// associated Taproot Asset commitment.
 	InputCommitments tappsbt.InputCommitments
 
+	// ZeroValueInputs is a list of zero-value UTXOs that should be swept
+	// as additional inputs to the transaction.
+	ZeroValueInputs []ZeroValueInput
+
 	// SendManifests is a map of send manifests that need to be sent to the
 	// auth mailbox server to complete an address V2 transfer. It is keyed
 	// by the anchor output index.

tapfreighter/wallet.go

@@ -172,6 +172,10 @@ type AnchorVTxnsParams struct {
 	// PassivePackets is a list of all the virtual transactions which
 	// re-anchor passive assets.
 	PassivePackets []*tappsbt.VPacket
+
+	// ZeroValueInputs is a list of zero-value UTXOs that should be swept
+	// as additional inputs to the transaction.
+	ZeroValueInputs []ZeroValueInput
 }
 
 // WalletConfig holds the configuration for a new Wallet.
@@ -248,6 +252,10 @@ type FundedVPacket struct {
 	// InputCommitments is a map from virtual package input index to its
 	// associated Taproot Asset commitment.
 	InputCommitments tappsbt.InputCommitments
+
+	// ZeroValueInputs is a list of zero-value UTXOs that should be swept
+	// as additional inputs to the transaction.
+	ZeroValueInputs []ZeroValueInput
 }
 
 // FundAddressSend funds a virtual transaction, selecting assets to spend in
@@ -684,6 +692,17 @@ func (f *AssetWallet) FundPacket(ctx context.Context,
 		return nil, err
 	}
 
+	// Fetch zero-value UTXOs that should be swept as additional inputs.
+	zeroValueInputs, err := f.cfg.CoinSelector.FetchZeroValueAnchorUTXOs(
+		ctx,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch zero-value "+
+			"UTXOs: %w", err)
+	}
+
+	pkt.ZeroValueInputs = zeroValueInputs
+
 	success = true
 	return pkt, nil
 }
@@ -810,6 +829,17 @@ func (f *AssetWallet) FundBurn(ctx context.Context,
 			len(fundedPkt.VPackets))
 	}
 
+	// Fetch zero-value UTXOs that should be swept as additional inputs.
+	zeroValueInputs, err := f.cfg.CoinSelector.FetchZeroValueAnchorUTXOs(
+		ctx,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch zero-value "+
+			"UTXOs: %w", err)
+	}
+
+	fundedPkt.ZeroValueInputs = zeroValueInputs
+
 	// Don't release the coins we've selected, as so far we've been
 	// successful.
 	success = true
@@ -1191,28 +1221,33 @@ func (f *AssetWallet) AnchorVirtualTransactions(ctx context.Context,
 	// it itself.
 	addAnchorPsbtInputs(sendPacket, params.ActivePackets)
 
+	// Add zero-value inputs that should be swept as additional inputs.
+	numZeroValueInputs := len(params.ZeroValueInputs)
+	if numZeroValueInputs > 0 {
+		log.Infof("Sweeping %d zero-value UTXOs", numZeroValueInputs)
+		addZeroValuePsbtInputs(
+			sendPacket, params.ZeroValueInputs,
+			f.cfg.ChainParams.HDCoinType,
+		)
+	}
+
 	// We now fund the packet, placing the change on the last output.
 	anchorPkt, err := f.cfg.Wallet.FundPsbt(
 		ctx, sendPacket, 1, params.FeeRate, -1,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("unable to fund psbt: %w", err)
 	}
-
-	log.Infof("Received funded PSBT packet")
-	log.Tracef("Packet: %v", spew.Sdump(anchorPkt.Pkt))
+	log.Tracef("Got funded PSBT packet: %v", spew.Sdump(anchorPkt.Pkt))
 
 	// With all the input and output information in the packet, we
 	// can now ask lnd to sign it, and then extract the final
 	// version ourselves.
-	log.Debugf("Signing PSBT")
-	log.Tracef("PSBT: %s", spew.Sdump(anchorPkt))
 	signedPsbt, err := f.cfg.Wallet.SignPsbt(ctx, anchorPkt.Pkt)
 	if err != nil {
 		return nil, fmt.Errorf("unable to sign psbt: %w", err)
 	}
-	log.Debugf("Got signed PSBT")
-	log.Tracef("PSBT: %s", spew.Sdump(signedPsbt))
+	log.Tracef("Got signed PSBT: %s", spew.Sdump(signedPsbt))
 
 	// Before we finalize, we need to calculate the actual, final fees that
 	// we pay.
@@ -1380,3 +1415,44 @@ func addAnchorPsbtInputs(btcPkt *psbt.Packet, vPackets []*tappsbt.VPacket) {
 
 	}
 }
+
+// addZeroValuePsbtInputs adds zero-value UTXOs as inputs to the PSBT.
+func addZeroValuePsbtInputs(btcPkt *psbt.Packet,
+	zeroValueInputs []ZeroValueInput, coinType uint32) {
+
+	for _, utxo := range zeroValueInputs {
+		// Check if this input is already added to avoid duplicates.
+		if tapsend.HasInput(btcPkt.UnsignedTx, utxo.GetOutPoint()) {
+			continue
+		}
+
+		// Create the BIP32 derivation info for signing.
+		bip32Derivation, trDerivation := tappsbt.
+			Bip32DerivationFromKeyDesc(
+				utxo.GetInternalKey(), coinType,
+			)
+
+		btcPkt.Inputs = append(btcPkt.Inputs, psbt.PInput{
+			WitnessUtxo: &wire.TxOut{
+				Value:    int64(utxo.GetOutputValue()),
+				PkScript: utxo.GetPkScript(),
+			},
+			SighashType: txscript.SigHashDefault,
+			Bip32Derivation: []*psbt.Bip32Derivation{
+				bip32Derivation,
+			},
+			TaprootInternalKey: schnorr.SerializePubKey(
+				utxo.GetInternalKey().PubKey,
+			),
+			TaprootBip32Derivation: []*psbt.TaprootBip32Derivation{
+				trDerivation,
+			},
+			TaprootMerkleRoot: utxo.GetMerkleRoot(),
+		})
+		btcPkt.UnsignedTx.TxIn = append(
+			btcPkt.UnsignedTx.TxIn, &wire.TxIn{
+				PreviousOutPoint: utxo.GetOutPoint(),
+			},
+		)
+	}
+}