itest: make script key check in AssertSendEvents optional

The script key check in AssertSendEvents is now optional. sendAsset
no longer relies on the script key for event filtering.

Author: ffranr

itest/addrs_test.go

@@ -3,6 +3,8 @@ package itest
 import (
 	"bytes"
 	"context"
+	"fmt"
+	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/wire"
@@ -964,25 +966,40 @@ func sendAsset(t *harnessTest, sender *tapdHarness,
 
 	require.NotEmpty(t.t, options.sendAssetRequest.TapAddrs)
 
-	// We need the first address's scriptkey to subscribe to events.
-	firstAddr, err := address.DecodeAddress(
-		options.sendAssetRequest.TapAddrs[0], &address.RegressionNetTap,
-	)
-	require.NoError(t.t, err)
-	scriptKey := firstAddr.ScriptKey.SerializeCompressed()
+	// Assign a default transfer label using a Unix timestamp if none is
+	// provided. This will be used in filtering send events.
+	if options.sendAssetRequest.Label == "" {
+		options.sendAssetRequest.Label = fmt.Sprintf(
+			"%d", time.Now().UnixNano(),
+		)
+	}
 
+	// Construct send event stream.
 	ctxc, streamCancel := context.WithCancel(ctxb)
 	stream, err := sender.SubscribeSendEvents(
 		ctxc, &taprpc.SubscribeSendEventsRequest{
-			FilterScriptKey: scriptKey,
+			FilterLabel: options.sendAssetRequest.Label,
 		},
 	)
 	require.NoError(t.t, err)
+
+	// Formulate a subscription handler for the send event stream.
 	sub := &EventSubscription[*taprpc.SendEvent]{
 		ClientEventStream: stream,
 		Cancel:            streamCancel,
+
+		// Use the filter callback to ensure that the server side filter
+		// is working as expected.
+		ShouldNotify: func(e *taprpc.SendEvent) (bool, error) {
+			require.Equal(
+				t.t, e.TransferLabel,
+				options.sendAssetRequest.Label,
+			)
+			return true, nil
+		},
 	}
 
+	// Kick off the send asset request.
 	resp, err := sender.SendAsset(ctxt, &options.sendAssetRequest)
 	if options.errText != "" {
 		require.ErrorContains(t.t, err, options.errText)
@@ -992,8 +1009,12 @@ func sendAsset(t *harnessTest, sender *tapdHarness,
 	require.NoError(t.t, err)
 
 	// We'll get events up to the point where we broadcast the transaction.
+	//
+	// Don't specify a target script key here, we are already filtering
+	// events by the label.
+	var targetScriptKey []byte = nil
 	AssertSendEvents(
-		t.t, scriptKey, sub,
+		t.t, targetScriptKey, sub,
 		tapfreighter.SendStateVirtualCommitmentSelect,
 		tapfreighter.SendStateBroadcast,
 	)

itest/assertions.go

@@ -961,6 +961,36 @@ func AssertReceiveEvents(t *testing.T, addr *taprpc.Addr,
 	}
 }
 
+// makeFilterSendEventScriptKey returns a filter function that checks if the
+// given script key is present in the send event. If it is, the event is
+// included in the stream.
+func makeFilterSendEventScriptKey(
+	scriptKey btcec.PublicKey) func(*taprpc.SendEvent) (bool, error) {
+
+	return func(event *taprpc.SendEvent) (bool, error) {
+		for _, vPacketBytes := range event.VirtualPackets {
+			vPkt, err := tappsbt.Decode(vPacketBytes)
+			if err != nil {
+				return false, err
+			}
+
+			for _, vOut := range vPkt.Outputs {
+				if vOut.ScriptKey.PubKey == nil {
+					continue
+				}
+
+				// This packet sends to the filtered script key,
+				// we want to include this event.
+				if vOut.ScriptKey.PubKey.IsEqual(&scriptKey) {
+					return true, nil
+				}
+			}
+		}
+
+		return false, nil
+	}
+}
+
 // AssertSendEventsComplete makes sure the two remaining events for the given
 // script key are sent on the stream.
 func AssertSendEventsComplete(t *testing.T, scriptKey []byte,
@@ -974,39 +1004,27 @@ func AssertSendEventsComplete(t *testing.T, scriptKey []byte,
 
 // AssertSendEvents makes sure all events with incremental status are sent
 // on the stream for the given script key.
-func AssertSendEvents(t *testing.T, scriptKey []byte,
+func AssertSendEvents(t *testing.T, targetScriptKey []byte,
 	stream *EventSubscription[*taprpc.SendEvent], from,
 	to tapfreighter.SendState) {
 
 	success := make(chan struct{})
 	timeout := time.After(defaultWaitTimeout)
 	startStatus := from
 
-	targetScriptKey, err := btcec.ParsePubKey(scriptKey)
-	require.NoError(t, err)
-
-	sendsToKey := func(e *taprpc.SendEvent) bool {
-		for _, vPacketBytes := range e.VirtualPackets {
-			vPkt, err := tappsbt.Decode(vPacketBytes)
-			require.NoError(t, err)
-
-			for _, vOut := range vPkt.Outputs {
-				if vOut.ScriptKey.PubKey == nil {
-					continue
-				}
-
-				// This packet sends to the filtered script key,
-				// we want to include this event.
-				if vOut.ScriptKey.PubKey.IsEqual(
-					targetScriptKey,
-				) {
+	// By default, if the target script key is not given we will accept all
+	// send events.
+	sendsToKey := func(*taprpc.SendEvent) (bool, error) {
+		return true, nil
+	}
 
-					return true
-				}
-			}
-		}
+	// If a target script key is given, we will only accept send events that
+	// relate to that key.
+	if targetScriptKey != nil {
+		targetScriptKey, err := btcec.ParsePubKey(targetScriptKey)
+		require.NoError(t, err)
 
-		return false
+		sendsToKey = makeFilterSendEventScriptKey(*targetScriptKey)
 	}
 
 	// To make sure we don't forever hang on receiving on the stream, we'll
@@ -1026,7 +1044,11 @@ func AssertSendEvents(t *testing.T, scriptKey []byte,
 		event, err := stream.Recv()
 		require.NoError(t, err, "receiving send event")
 
-		require.True(t, sendsToKey(event))
+		// Ensure that the event complies with the target script key
+		// check.
+		res, err := sendsToKey(event)
+		require.NoError(t, err)
+		require.True(t, res)
 
 		// Check the event's error field for unexpected errors. Perform
 		// this check before verifying the expected send state, as