itest: manually broadcast anchor tx in testPsbtExternalCommit

Update testPsbtExternalCommit to manually broadcast the anchor
transaction. We ensure that tapd skips broadcasting the anchor
transaction itself.

Author: ffranr

itest/psbt_test.go

@@ -7,12 +7,15 @@ import (
 	"fmt"
 	"net/url"
 	"testing"
+	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
 	"github.com/btcsuite/btcd/btcutil/psbt"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcwallet/waddrmgr"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightninglabs/taproot-assets/address"
@@ -2611,18 +2614,80 @@ func testPsbtExternalCommit(t *harnessTest) {
 
 	btcPacket = signPacket(t.t, aliceLnd, btcPacket)
 	btcPacket = FinalizePacket(t.t, aliceLnd.RPC, btcPacket)
+
+	transferLabel := "itest-psbt-external-commit"
+
+	// Subscribe to the send event stream so we can verify the sender's
+	// state transitions during this test.
+	ctx, streamCancel := context.WithCancel(ctxb)
+	stream, err := aliceTapd.SubscribeSendEvents(
+		ctx, &taprpc.SubscribeSendEventsRequest{
+			FilterLabel: transferLabel,
+		},
+	)
+	require.NoError(t.t, err)
+	sendEvents := &EventSubscription[*taprpc.SendEvent]{
+		ClientEventStream: stream,
+		Cancel:            streamCancel,
+	}
+
+	// Execute the transfer but skip anchor transaction broadcast. This
+	// simulates a packaging workflow where broadcasting is handled
+	// externally.
 	sendResp := PublishAndLogTransfer(
 		t.t, aliceTapd, btcPacket, activeAssets, passiveAssets,
-		commitResp,
+		commitResp, withSkipAnchorTxBroadcast(),
+		withLabel(transferLabel),
 	)
 
+	// Assert that the state machine transitions directly to waiting for
+	// tx confirmation, skipping the broadcast state.
+	require.Eventually(t.t, func() bool {
+		isMatchingState := func(msg *taprpc.SendEvent) bool {
+			lastState := tapfreighter.SendStateStorePreBroadcast
+			nextState := tapfreighter.SendStateWaitTxConf
+
+			return msg.SendState == lastState.String() &&
+				msg.NextSendState == nextState.String()
+		}
+
+		for {
+			msg, err := sendEvents.Recv()
+			if err != nil {
+				return false
+			}
+
+			return isMatchingState(msg)
+		}
+	}, defaultWaitTimeout, time.Second)
+
+	// Unmarshal the anchor transaction.
+	var anchorTx wire.MsgTx
+	reader := bytes.NewReader(sendResp.Transfer.AnchorTx)
+	err = anchorTx.Deserialize(reader)
+	require.NoError(t.t, err)
+
+	// Ensure that the anchor PSBT matches the returned anchor
+	// transaction.
+	require.Equal(t.t, anchorTx.TxHash(), btcPacket.UnsignedTx.TxHash())
+
+	// Assert that the anchor transaction is not in the mempool.
+	miner := t.lndHarness.Miner()
+	miner.AssertTxnsNotInMempool([]chainhash.Hash{
+		anchorTx.TxHash(),
+	})
+
+	// Add the anchor transaction to the mempool and mine.
+	miner.MineBlockWithTx(&anchorTx)
+
+	// Assert that the transfer has the correct number of outputs.
 	expectedAmounts := []uint64{
 		targetAsset.Amount - assetsToSend, assetsToSend,
 	}
-	ConfirmAndAssertOutboundTransferWithOutputs(
+	AssertAssetOutboundTransferWithOutputs(
 		t.t, t.lndHarness.Miner().Client, aliceTapd,
-		sendResp, targetAssetGenesis.AssetId, expectedAmounts,
-		0, 1, len(expectedAmounts),
+		sendResp.Transfer, targetAssetGenesis.AssetId, expectedAmounts,
+		0, 1, len(expectedAmounts), false,
 	)
 
 	// And now the event should be completed on both sides.