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,18 +1894,33 @@ 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 {
+		// Gather all outpoints to unlock in a single array
+		var outpoints []wire.OutPoint
 
+		// Add input commitment outpoints
 		for prevID := range pkg.InputCommitments {
 			log.Debugf("Unlocking input %v", prevID.OutPoint)
+			outpoints = append(outpoints, prevID.OutPoint)
+		}
+
+		// Add zero-value inputs
+		zeroValueOutpoints := fn.Map(
+			pkg.ZeroValueInputs,
+			func(z *ZeroValueInput) wire.OutPoint {
+				return z.OutPoint
+			},
+		)
+		outpoints = append(outpoints, zeroValueOutpoints...)
 
+		// Release all coins in a single call
+		if len(outpoints) > 0 {
 			err := p.cfg.AssetWallet.ReleaseCoins(
-				ctx, prevID.OutPoint,
+				ctx, outpoints...,
 			)
 			if err != nil {
-				log.Warnf("Unable to unlock input %v: %v",
-					prevID.OutPoint, err)
+				log.Warnf("Unable to unlock inputs: %v", err)
 			}
 		}
 	}

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")
@@ -150,6 +151,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),
+			)
 		})
 	}
 }