tapcfg+tapfreighter: configure sweeping with wallet flag

Author: darioAnongba

config.go

@@ -190,6 +190,10 @@ type Config struct {
 
 	ChainPorter tapfreighter.Porter
 
+	// SweepZeroValueAnchorUtxos toggles sweeping zero-value UTXOs into
+	// anchor transactions for sends and burns.
+	SweepZeroValueAnchorUtxos bool
+
 	// FsmDaemonAdapters is a set of adapters that allow a state machine to
 	// interact with external daemons.
 	FsmDaemonAdapters *lndservices.LndFsmDaemonAdapters

docs/release-notes/release-notes-0.8.0.md

@@ -35,7 +35,8 @@
 - [Garbage collection of zero-value UTXOs](https://github.com/lightninglabs/taproot-assets/pull/1832)
   by sweeping tombstones and burn outputs when executing onchain transactions.
   Garbage collection will be executed on every burn, transfer or call to
-  `AnchorVirtualPsbts`.
+  `AnchorVirtualPsbts`. A new configuration is available to control the sweeping 
+  via the flag `wallet.sweep-zero-value-anchor-utxos`.
 
 ## RPC Updates
 

itest/integration_test.go

@@ -119,7 +119,7 @@ func TestTaprootAssetsDaemon(t *testing.T) {
 			// assure no state is taken over between runs.
 			tapdHarness, uniHarness, proofCourier := setupHarnesses(
 				t1, ht, lndHarness, uniServerLndHarness,
-				testCase.proofCourierType,
+				testCase.proofCourierType, testCase.tapdOptions...,
 			)
 
 			ht := ht.newHarnessTest(

itest/tapd_harness.go

@@ -139,6 +139,10 @@ type harnessOpts struct {
 	// the local oracle to the counterparty when requesting a quote.
 	sendPriceHint bool
 
+	// sweepZeroValueAnchorUtxos indicates whether zero-value anchor UTXOs
+	// should be swept into anchor transactions.
+	sweepZeroValueAnchorUtxos bool
+
 	// disableSupplyVerifierChainWatch when true prevents the supply
 	// verifier from starting state machines to watch on-chain outputs for
 	// spends. This option is intended for universe servers, where supply
@@ -197,6 +201,8 @@ func newTapdHarness(t *testing.T, ht *harnessTest, cfg tapdConfig,
 	tapCfg.ChainConf.Network = cfg.NetParams.Name
 	tapCfg.TapdDir = cfg.BaseDir
 	tapCfg.DebugLevel = *logLevel
+	tapCfg.Wallet.SweepZeroValueAnchorUtxos =
+		opts.sweepZeroValueAnchorUtxos
 
 	// Enable universe proof courier RPC endpoints. These endpoints are
 	// also used within some tests for transferring proofs.

itest/test_harness.go

@@ -70,6 +70,7 @@ type testCase struct {
 	name             string
 	test             func(t *harnessTest)
 	proofCourierType proof.CourierType
+	tapdOptions      []Option
 }
 
 // harnessTest wraps a regular testing.T providing enhanced error detection
@@ -270,7 +271,7 @@ func (h *harnessTest) addFederationServer(host string, target *tapdHarness) {
 // to each other through an in-memory gRPC connection.
 func setupHarnesses(t *testing.T, ht *harnessTest,
 	lndHarness *lntest.HarnessTest, uniServerLndHarness *node.HarnessNode,
-	proofCourierType proof.CourierType) (*tapdHarness,
+	proofCourierType proof.CourierType, tapdOpts ...Option) (*tapdHarness,
 	*universeServerHarness, proof.CourierHarness) {
 
 	// Create a new universe server harness and start it.
@@ -306,10 +307,11 @@ func setupHarnesses(t *testing.T, ht *harnessTest,
 	alice := lndHarness.NewNodeWithCoins("Alice", nil)
 
 	// Create a tapd that uses Alice and connect it to the universe server.
+	tapdOptions := append(tapdOpts, func(params *tapdHarnessParams) {
+		params.proofCourier = proofCourier
+	})
 	tapdHarness := setupTapdHarness(
-		t, ht, alice, universeServer, func(params *tapdHarnessParams) {
-			params.proofCourier = proofCourier
-		},
+		t, ht, alice, universeServer, tapdOptions...,
 	)
 	return tapdHarness, universeServer, proofCourier
 }
@@ -372,6 +374,10 @@ type tapdHarnessParams struct {
 	// sendPriceHint indicates whether the tapd should send price hints from
 	// the local oracle to the counterparty when requesting a quote.
 	sendPriceHint bool
+
+	// sweepZeroValueAnchorUtxos indicates whether zero-value anchor UTXOs
+	// should be swept into anchor transactions.
+	sweepZeroValueAnchorUtxos bool
 }
 
 // Option is a tapd harness option.
@@ -400,6 +406,14 @@ func WithSendPriceHint() Option {
 	}
 }
 
+// WithSweepZeroValueAnchorUtxos enables sweeping zero-value anchor UTXOs for
+// the tapd harness created with this option.
+func WithSweepZeroValueAnchorUtxos() Option {
+	return func(th *tapdHarnessParams) {
+		th.sweepZeroValueAnchorUtxos = true
+	}
+}
+
 // setupTapdHarness creates a new tapd that connects to the given lnd node
 // and to the given universe server.
 func setupTapdHarness(t *testing.T, ht *harnessTest,
@@ -434,6 +448,7 @@ func setupTapdHarness(t *testing.T, ht *harnessTest,
 		ho.disableSyncCache = params.disableSyncCache
 		ho.oracleServerAddress = params.oracleServerAddress
 		ho.sendPriceHint = params.sendPriceHint
+		ho.sweepZeroValueAnchorUtxos = params.sweepZeroValueAnchorUtxos
 	}
 
 	tapdCfg := tapdConfig{

itest/test_list_on_test.go

@@ -104,6 +104,13 @@ var allTestCases = []*testCase{
 	{
 		name: "zero value anchor sweep",
 		test: testZeroValueAnchorSweep,
+		tapdOptions: []Option{
+			WithSweepZeroValueAnchorUtxos(),
+		},
+	},
+	{
+		name: "zero value anchor accumulation",
+		test: testZeroValueAnchorAccumulation,
 	},
 	{
 		name: "restart receiver check balance",

itest/zero_value_anchor_test.go

@@ -2,6 +2,7 @@ package itest
 
 import (
 	"context"
+	"time"
 
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/taprpc"
@@ -176,3 +177,217 @@ func testZeroValueAnchorSweep(t *harnessTest) {
 		WithNumUtxos(0), WithNumAnchorUtxos(0),
 	)
 }
+
+// testZeroValueAnchorAccumulation tests that zero-value anchor outputs
+// accumulate when sweeping is disabled, and are swept when the node
+// is restarted with sweeping enabled.
+func testZeroValueAnchorAccumulation(t *harnessTest) {
+	ctxb := context.Background()
+
+	// Start Alice's node WITHOUT sweeping enabled.
+	// Note: t.tapd is already started without sweeping by default.
+
+	// Create Bob's node with sweeping enabled for receives.
+	bobLnd := t.lndHarness.NewNodeWithCoins("Bob", nil)
+	bobTapd := setupTapdHarness(t.t, t, bobLnd, t.universeServer)
+	defer func() {
+		require.NoError(t.t, bobTapd.stop(!*noDelete))
+	}()
+
+	// First, mint some assets to create zero-value UTXOs with.
+	rpcAssets1 := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{simpleAssets[0]},
+	)
+	genInfo1 := rpcAssets1[0].AssetGenesis
+	assetAmount := simpleAssets[0].Asset.Amount
+
+	// Test 1: Create a tombstone by sending ALL assets to Bob.
+	bobAddr1, err := bobTapd.NewAddr(ctxb, &taprpc.NewAddrRequest{
+		AssetId:      genInfo1.AssetId,
+		Amt:          assetAmount,
+		AssetVersion: rpcAssets1[0].Version,
+	})
+	require.NoError(t.t, err)
+
+	sendResp1, _ := sendAssetsToAddr(t, t.tapd, bobAddr1)
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner().Client, t.tapd, sendResp1,
+		genInfo1.AssetId,
+		[]uint64{0, assetAmount}, 0, 1,
+	)
+	AssertNonInteractiveRecvComplete(t.t, bobTapd, 1)
+
+	// Alice should have 1 tombstone UTXO.
+	AssertBalances(
+		t.t, t.tapd, 0, WithScriptKeyType(asset.ScriptKeyTombstone),
+		WithNumUtxos(1), WithNumAnchorUtxos(1),
+	)
+
+	// Test 2: Create a burn UTXO by burning another asset fully.
+	rpcAssets2 := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{simpleAssets[0]},
+	)
+	genInfo2 := rpcAssets2[0].AssetGenesis
+
+	// Full burn the asset to create a zero-value burn UTXO.
+	burnResp, err := t.tapd.BurnAsset(ctxb, &taprpc.BurnAssetRequest{
+		Asset: &taprpc.BurnAssetRequest_AssetId{
+			AssetId: genInfo2.AssetId,
+		},
+		AmountToBurn:     assetAmount,
+		ConfirmationText: "assets will be destroyed",
+	})
+	require.NoError(t.t, err)
+
+	AssertAssetOutboundTransferWithOutputs(
+		t.t, t.lndHarness.Miner().Client, t.tapd, burnResp.BurnTransfer,
+		[][]byte{genInfo2.AssetId},
+		[]uint64{assetAmount}, 1, 2, 1, true,
+	)
+
+	// Alice should now have 1 tombstone and 1 burn UTXO.
+	AssertBalances(
+		t.t, t.tapd, 0, WithScriptKeyType(asset.ScriptKeyTombstone),
+		WithNumUtxos(1), WithNumAnchorUtxos(1),
+	)
+	AssertBalances(
+		t.t, t.tapd, assetAmount,
+		WithScriptKeyType(asset.ScriptKeyBurn),
+		WithNumUtxos(1), WithNumAnchorUtxos(1),
+	)
+
+	// Test 3: Create another tombstone with a different asset.
+	rpcAssets3 := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{simpleAssets[0]},
+	)
+	genInfo3 := rpcAssets3[0].AssetGenesis
+
+	bobAddr2, err := bobTapd.NewAddr(ctxb, &taprpc.NewAddrRequest{
+		AssetId:      genInfo3.AssetId,
+		Amt:          assetAmount,
+		AssetVersion: rpcAssets3[0].Version,
+	})
+	require.NoError(t.t, err)
+
+	sendResp2, _ := sendAssetsToAddr(t, t.tapd, bobAddr2)
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner().Client, t.tapd, sendResp2,
+		genInfo3.AssetId, []uint64{0, assetAmount}, 2, 3,
+	)
+	AssertNonInteractiveRecvComplete(t.t, bobTapd, 2)
+
+	// Alice should now have 2 tombstones and 1 burn UTXO.
+	AssertBalances(
+		t.t, t.tapd, 0, WithScriptKeyType(asset.ScriptKeyTombstone),
+		WithNumUtxos(2), WithNumAnchorUtxos(2),
+	)
+
+	// Now restart Alice's node with sweeping enabled.
+
+	// Save the base directory to preserve the database.
+	baseDir := t.tapd.cfg.BaseDir
+	lndNode := t.tapd.cfg.LndNode
+	require.NoError(t.t, t.tapd.stop(false))
+
+	// Create a new tapd config with the same base directory to preserve
+	// state.
+	tapdCfg := tapdConfig{
+		NetParams: harnessNetParams,
+		LndNode:   lndNode,
+		BaseDir:   baseDir,
+	}
+
+	// Create a new harness with sweeping enabled.
+	aliceTapd, err := newTapdHarness(
+		t.t, t, tapdCfg,
+		func(ho *harnessOpts) {
+			ho.sweepZeroValueAnchorUtxos = true
+			ho.proofCourier = t.proofCourier
+		},
+	)
+	require.NoError(t.t, err)
+
+	// Start the new harness.
+	err = aliceTapd.start(false)
+	require.NoError(t.t, err)
+
+	// Replace the test harness's tapd reference.
+	oldTapd := t.tapd
+	t.tapd = aliceTapd
+	defer func() {
+		// Stop the new tapd and restore original for cleanup.
+		require.NoError(t.t, aliceTapd.stop(false))
+		t.tapd = oldTapd
+	}()
+
+	// Wait for the node to fully sync after restart.
+	time.Sleep(2 * time.Second)
+
+	// Verify that the zero-value UTXOs are still present after restart.
+	//nolint:lll
+	tombstoneUtxosAfterRestart, err := t.tapd.ListUtxos(ctxb, &taprpc.ListUtxosRequest{
+		ScriptKeyType: &taprpc.ScriptKeyTypeQuery{
+			Type: &taprpc.ScriptKeyTypeQuery_ExplicitType{
+				ExplicitType: taprpc.
+					ScriptKeyType_SCRIPT_KEY_TOMBSTONE,
+			},
+		},
+	})
+	require.NoError(t.t, err)
+	require.Len(t.t, tombstoneUtxosAfterRestart.ManagedUtxos, 2)
+
+	//nolint:lll
+	burnUtxosAfterRestart, err := t.tapd.ListUtxos(ctxb, &taprpc.ListUtxosRequest{
+		ScriptKeyType: &taprpc.ScriptKeyTypeQuery{
+			Type: &taprpc.ScriptKeyTypeQuery_ExplicitType{
+				ExplicitType: taprpc.
+					ScriptKeyType_SCRIPT_KEY_BURN,
+			},
+		},
+	})
+	require.NoError(t.t, err)
+	require.Len(t.t, burnUtxosAfterRestart.ManagedUtxos, 1)
+
+	// Test 4: Mint and send a new asset. This should sweep all accumulated
+	// zero-value UTXOs (2 tombstones + 1 burn).
+	rpcAssets4 := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{simpleAssets[0]},
+	)
+	genInfo4 := rpcAssets4[0].AssetGenesis
+
+	// Send partial amount to create a normal transfer that should sweep
+	// all zero-value UTXOs.
+	partialAmount := assetAmount / 2
+	bobAddr3, err := bobTapd.NewAddr(ctxb, &taprpc.NewAddrRequest{
+		AssetId:      genInfo4.AssetId,
+		Amt:          partialAmount,
+		AssetVersion: rpcAssets4[0].Version,
+	})
+	require.NoError(t.t, err)
+
+	sendResp3, _ := sendAssetsToAddr(t, t.tapd, bobAddr3)
+
+	// This transfer should have swept all 3 zero-value UTXOs as inputs.
+	// The expected number of inputs is:
+	// 1 (new asset) + 3 (swept zero-value).
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner().Client, t.tapd, sendResp3,
+		genInfo4.AssetId,
+		[]uint64{partialAmount, partialAmount}, 3, 4,
+	)
+	AssertNonInteractiveRecvComplete(t.t, bobTapd, 3)
+
+	// All zero-value UTXOs should have been swept.
+	AssertBalances(
+		t.t, t.tapd, 0, WithScriptKeyType(asset.ScriptKeyTombstone),
+		WithNumUtxos(0), WithNumAnchorUtxos(0),
+	)
+	AssertBalances(
+		t.t, t.tapd, 0, WithScriptKeyType(asset.ScriptKeyBurn),
+		WithNumUtxos(0), WithNumAnchorUtxos(0),
+	)
+}

rpcserver.go

@@ -2671,11 +2671,19 @@ func (r *rpcServer) AnchorVirtualPsbts(ctx context.Context,
 			prevID.OutPoint.String())
 	}
 
-	// Fetch zero-value UTXOs that should be swept as additional inputs.
-	zeroValueInputs, err := r.cfg.AssetStore.FetchZeroValueAnchorUTXOs(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("unable to fetch zero-value "+
-			"UTXOs: %w", err)
+	// Fetch zero-value UTXOs that should be swept as additional inputs if
+	// the feature is enabled.
+	var (
+		zeroValueInputs []*tapfreighter.ZeroValueInput
+		err             error
+	)
+	if r.cfg.SweepZeroValueAnchorUtxos {
+		zeroValueInputs, err = r.cfg.AssetStore.
+			FetchZeroValueAnchorUTXOs(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("unable to fetch zero-value "+
+				"UTXOs: %w", err)
+		}
 	}
 
 	resp, err := r.cfg.ChainPorter.RequestShipment(

sample-tapd.conf

@@ -412,6 +412,10 @@
 ; Value must be a valid float ranging from 0.00 to 1.00.
 ; wallet.psbt-max-fee-ratio=0.75
 
+; Sweep zero-value anchor UTXOs into send and burn anchor transactions.
+; Disabled by default.
+; wallet.sweep-zero-value-anchor-utxos=false
+
 [address]
 
 ; If true, tapd will not try to sync issuance proofs for unknown assets when