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,8 @@ 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.
+		if !out.IsSpendable() {
 			continue
 		}
 
@@ -1267,23 +1267,30 @@ func (p *ChainPorter) importLocalAddresses(ctx context.Context,
 			return err
 		}
 
+		log.Infof("Importing anchor output key for output %d "+
+			"(isTombstone=%v, isBurn=%v): outpoint=%v, key=%x",
+			idx, out.IsTombstone(), out.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
 		// it for spends and also takes account of the BTC we used in
 		// the transfer.
 		_, 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
+		if err != nil {
+			// 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.
+			if strings.Contains(err.Error(), "already exists") {
+				log.Tracef("Anchor output key already exists "+
+					"(outpoint=%v): %w",
+					out.Anchor.OutPoint, err)
+				continue
+			}
 
-		default:
-			return err
+			return fmt.Errorf("unable to import anchor output "+
+				"key: %w", err)
 		}
 	}
 
@@ -1446,6 +1453,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 +1599,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 {
@@ -1695,8 +1704,8 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		parcel, err := ConvertToTransfer(
 			currentHeight, currentPkg.VirtualPackets,
 			currentPkg.AnchorTx, currentPkg.PassiveAssets,
-			isLocalKey, currentPkg.Label,
-			currentPkg.SkipAnchorTxBroadcast,
+			currentPkg.ZeroValueInputs, isLocalKey,
+			currentPkg.Label, currentPkg.SkipAnchorTxBroadcast,
 		)
 		if err != nil {
 			p.unlockInputs(ctx, &currentPkg)
@@ -1715,6 +1724,8 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		// Write the parcel to disk as a pending parcel. This step also
 		// records the transfer details (e.g., reference to the anchor
 		// transaction ID, transfer outputs and inputs) to the database.
+		// This will also extend the leases for both asset inputs and
+		// zero-value UTXOs to prevent them from being used elsewhere.
 		err = p.cfg.ExportLog.LogPendingParcel(
 			ctx, parcel, defaultWalletLeaseIdentifier,
 			time.Now().Add(defaultBroadcastCoinLeaseDuration),
@@ -1883,9 +1894,8 @@ func (p *ChainPorter) unlockInputs(ctx context.Context, pkg *sendPackage) {
 	// sanity-check that we have known input commitments to unlock, since
 	// that might not always be the case (for example if another party
 	// contributes inputs).
-	if pkg.SendState < SendStateStorePreBroadcast &&
-		len(pkg.InputCommitments) > 0 {
-
+	// Also unlock any zero-value UTXOs that were leased for this package.
+	if pkg.SendState < SendStateStorePreBroadcast {
 		for prevID := range pkg.InputCommitments {
 			log.Debugf("Unlocking input %v", prevID.OutPoint)
 
@@ -1897,6 +1907,20 @@ func (p *ChainPorter) unlockInputs(ctx context.Context, pkg *sendPackage) {
 					prevID.OutPoint, err)
 			}
 		}
+
+		zeroValueOutpoints := fn.Map(
+			pkg.ZeroValueInputs,
+			func(z *ZeroValueInput) wire.OutPoint {
+				return z.OutPoint
+			},
+		)
+
+		err := p.cfg.AssetWallet.ReleaseCoins(
+			ctx, zeroValueOutpoints...,
+		)
+		if err != nil {
+			log.Warnf("Unable to unlock zero-value inputs: %v", err)
+		}
 	}
 
 	// If we're in another state, the anchor transaction has been created,

tapfreighter/coin_select.go

@@ -114,20 +114,6 @@ func (s *CoinSelect) SelectCoins(ctx context.Context,
 	return selectedCoins, nil
 }
 
-// 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).
-func (s *CoinSelect) LeaseCoins(ctx context.Context, leaseOwner [32]byte,
-	expiry time.Time, utxoOutpoints ...wire.OutPoint) error {
-
-	s.coinLock.Lock()
-	defer s.coinLock.Unlock()
-
-	return s.coinLister.LeaseCoins(
-		ctx, leaseOwner, expiry, utxoOutpoints...,
-	)
-}
-
 // ReleaseCoins releases/unlocks coins that were previously leased and makes
 // them available for coin selection again.
 func (s *CoinSelect) ReleaseCoins(ctx context.Context,
@@ -199,4 +185,46 @@ func (s *CoinSelect) selectForAmount(minTotalAmount uint64,
 	return selectedCommitments, nil
 }
 
+// SelectZeroValueCoins fetches all managed UTXOs that contain only
+// zero-value assets (tombstones and burns). The selected UTXOs are
+// leased for the default lease duration.
+func (s *CoinSelect) SelectZeroValueCoins(ctx context.Context) (
+	[]*ZeroValueInput, error) {
+
+	s.coinLock.Lock()
+	defer s.coinLock.Unlock()
+
+	// Fetch all zero-value UTXOs that are eligible for sweeping.
+	zeroValueInputs, err := s.coinLister.FetchZeroValueAnchorUTXOs(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch zero-value UTXOs: %w",
+			err)
+	}
+
+	// We now need to lock/lease/reserve those selected coins so
+	// that they can't be used by other processes.
+	if len(zeroValueInputs) > 0 {
+		expiry := time.Now().Add(defaultCoinLeaseDuration)
+		zeroValueOutpoints := fn.Map(
+			zeroValueInputs,
+			func(z *ZeroValueInput) wire.OutPoint {
+				return z.OutPoint
+			},
+		)
+		err = s.coinLister.LeaseCoins(
+			ctx, defaultWalletLeaseIdentifier, expiry,
+			zeroValueOutpoints...,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to lease zero-value "+
+				"UTXOs: %w", err)
+		}
+
+		log.Debugf("Selected and leased %d zero-value UTXOs",
+			len(zeroValueInputs))
+	}
+
+	return zeroValueInputs, nil
+}
+
 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/fund.go

@@ -26,7 +26,8 @@ import (
 func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 	keyRing KeyRing, addrBook AddrBook, fundDesc *tapsend.FundingDescriptor,
 	vPktTemplate *tappsbt.VPacket,
-	selectedCommitments []*AnchoredCommitment) (*FundedVPacket, error) {
+	selectedCommitments []*AnchoredCommitment,
+	zeroValueInputs []*ZeroValueInput) (*FundedVPacket, error) {
 
 	if vPktTemplate.ChainParams == nil {
 		return nil, errors.New("chain params not set in virtual packet")
@@ -159,6 +160,7 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 	return &FundedVPacket{
 		VPackets:         allPackets,
 		InputCommitments: inputCommitments,
+		ZeroValueInputs:  zeroValueInputs,
 	}, nil
 }
 

tapfreighter/fund_test.go

@@ -321,6 +321,7 @@ func TestFundPacket(t *testing.T) {
 		vPkt                     *tappsbt.VPacket
 		inputProofs              []*proof.Proof
 		selectedCommitments      []*AnchoredCommitment
+		zeroValueInputs          []*ZeroValueInput
 		keysDerived              int
 		expectedErr              string
 		expectedInputCommitments tappsbt.InputCommitments
@@ -350,6 +351,28 @@ func TestFundPacket(t *testing.T) {
 				Commitment:  inputCommitment,
 				Asset:       &inputAsset,
 			}},
+			zeroValueInputs: []*ZeroValueInput{
+				{
+					OutPoint: wire.OutPoint{
+						Hash:  test.RandHash(),
+						Index: 1,
+					},
+					OutputValue: 1000,
+					InternalKey: internalKey,
+					MerkleRoot:  test.RandBytes(32),
+					PkScript:    test.RandBytes(34),
+				},
+				{
+					OutPoint: wire.OutPoint{
+						Hash:  test.RandHash(),
+						Index: 0,
+					},
+					OutputValue: 546,
+					InternalKey: internalKey,
+					MerkleRoot:  test.RandBytes(32),
+					PkScript:    test.RandBytes(34),
+				},
+			},
 			keysDerived: 3,
 			expectedInputCommitments: tappsbt.InputCommitments{
 				inputPrevID: inputCommitment,
@@ -765,6 +788,7 @@ func TestFundPacket(t *testing.T) {
 			result, err := createFundedPacketWithInputs(
 				ctx, exporter, keyRing, addrBook,
 				tc.fundDesc, tc.vPkt, tc.selectedCommitments,
+				tc.zeroValueInputs,
 			)
 
 			keyRing.AssertNumberOfCalls(
@@ -788,6 +812,13 @@ func TestFundPacket(t *testing.T) {
 				tt, result.VPackets,
 				tc.expectedOutputs(tt, keyRing),
 			)
+
+			// Verify zero-value inputs are correctly added to the
+			// result.
+			require.Len(
+				tt, result.ZeroValueInputs,
+				len(tc.zeroValueInputs),
+			)
 		})
 	}
 }

tapfreighter/interface.go

@@ -168,6 +168,11 @@ 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 +200,29 @@ 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
+
+	// SelectZeroValueCoins selects all managed UTXOs that contain only
+	// zero-value assets (tombstones and burns). The selected UTXOs are
+	// leased for the default lease duration.
+	SelectZeroValueCoins(ctx context.Context) ([]*ZeroValueInput, error)
+}
+
+// ZeroValueInput represents a zero-value UTXO that should be swept.
+type ZeroValueInput struct {
+	// OutPoint is the outpoint of the zero-value UTXO.
+	OutPoint wire.OutPoint
+
+	// OutputValue is the satoshi value of the zero-value UTXO.
+	OutputValue btcutil.Amount
+
+	// InternalKey is the internal key descriptor for the zero-value UTXO.
+	InternalKey keychain.KeyDescriptor
+
+	// MerkleRoot is the taproot merkle root for the zero-value UTXO.
+	MerkleRoot []byte
+
+	// PkScript is the pkScript of the anchor output.
+	PkScript []byte
 }
 
 // TransferInput represents the database level input to an asset transfer.
@@ -431,6 +459,29 @@ func (out *TransferOutput) UniqueKey() (OutputIdentifier, error) {
 	), nil
 }
 
+// IsTombstone returns true if the transfer output is a tombstone.
+func (out *TransferOutput) IsTombstone() bool {
+	return out.Amount == 0 && out.ScriptKey.PubKey.IsEqual(asset.NUMSPubKey)
+}
+
+// IsBurn returns true if the transfer output is a burn.
+func (out *TransferOutput) IsBurn() bool {
+	return out.Amount == 0 && len(out.WitnessData) > 0 &&
+		asset.IsBurnKey(
+			out.ScriptKey.PubKey, out.WitnessData[0],
+		)
+}
+
+// IsLocal returns true if the transfer output is a local script key.
+func (out *TransferOutput) IsLocal() bool {
+	return out.ScriptKeyLocal
+}
+
+// IsSpendable returns true if the transfer output is spendable.
+func (out *TransferOutput) IsSpendable() bool {
+	return out.IsLocal() || out.IsTombstone() || out.IsBurn()
+}
+
 // OutboundParcel represents the database level delta of an outbound Taproot
 // Asset parcel (outbound spend). A spend will destroy a series of assets listed
 // as inputs, and re-create them as new outputs. Along the way some assets may
@@ -480,6 +531,10 @@ type OutboundParcel struct {
 	// transfer.
 	Outputs []TransferOutput
 
+	// ZeroValueInputs is the set of zero-value UTXOs that are being swept
+	// as additional inputs to the Bitcoin transaction.
+	ZeroValueInputs []*ZeroValueInput
+
 	// Label is a user provided label for the transfer.
 	Label string
 
@@ -498,6 +553,7 @@ func (o *OutboundParcel) Copy() *OutboundParcel {
 		ChainFees:             o.ChainFees,
 		Inputs:                fn.CopySlice(o.Inputs),
 		Outputs:               fn.CopySlice(o.Outputs),
+		ZeroValueInputs:       fn.CopySlice(o.ZeroValueInputs),
 		Label:                 o.Label,
 		SkipAnchorTxBroadcast: o.SkipAnchorTxBroadcast,
 	}
@@ -574,6 +630,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