loadtest: add sendV2 loadtest

This commit adds a refactored version of the send test, which uses less
assertions and rpc calls. This is meant to speed things up compared to
the old test, plus offer some more coverage by utilizing normal assets
and balances greater than 1 (case for collectibles).

Author: GeorgeTsagk

itest/loadtest/load_test.go

@@ -47,6 +47,10 @@ var loadTestCases = []testCase{
 		name: "send",
 		fn:   sendTest,
 	},
+	{
+		name: "sendV2",
+		fn:   sendTestV2,
+	},
 	{
 		name: "multisig",
 		fn:   multisigTest,

itest/loadtest/send_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	prand "math/rand"
+	"math/rand/v2"
 	"testing"
 	"time"
 
@@ -54,7 +55,156 @@ func sendTest(t *testing.T, ctx context.Context, cfg *Config) {
 	}
 }
 
-// sendAssets sends the given number of assets of the given type from the given
+// sendTestV2 checks that we are able to send assets between the two nodes. It
+// is a more performant and lightweight version of sendTest, as it uses less
+// assertions and RPC calls.
+func sendTestV2(t *testing.T, ctx context.Context, cfg *Config) {
+	// Start by initializing all our client connections.
+	alice, bob, bitcoinClient := initClients(t, ctx, cfg)
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, cfg.TestTimeout)
+	defer cancel()
+
+	sendType := stringToAssetType(cfg.SendAssetType)
+
+	// Alice is set to be the minter in mintV2, so we use Alice's universe.
+	var (
+		uniHost = fmt.Sprintf(
+			"%s:%d", alice.cfg.Host, alice.cfg.Port,
+		)
+	)
+
+	// Let's make sure Bob is aware of all the assets that Alice may have
+	// minted.
+	itest.SyncUniverses(ctx, t, bob, alice, uniHost, cfg.TestTimeout)
+
+	// We now retrieve Alice and Bob's balances just once, and will re-use
+	// them in future function calls. Any update to the balances will be
+	// directly applied to these response objects, to skip future calls to
+	// ListBalances.
+	resAlice, err := alice.ListBalances(ctx, &taprpc.ListBalancesRequest{
+		GroupBy: &taprpc.ListBalancesRequest_AssetId{
+			AssetId: true,
+		},
+	})
+	require.NoError(t, err)
+
+	resBob, err := bob.ListBalances(ctx, &taprpc.ListBalancesRequest{
+		GroupBy: &taprpc.ListBalancesRequest_AssetId{
+			AssetId: true,
+		},
+	})
+	require.NoError(t, err)
+
+	for i := 1; i <= cfg.NumSends; i++ {
+		var (
+			sender, receiver *rpcClient
+			senderAssets     map[string]*taprpc.AssetBalance
+		)
+
+		// Assets may be sent in both directions, so we make a random
+		// draw to conclude who the sender is.
+		draw := rand.IntN(2)
+
+		switch draw {
+		case 0:
+			sender = alice
+			senderAssets = resAlice.AssetBalances
+			receiver = bob
+
+		case 1:
+			sender = bob
+			senderAssets = resBob.AssetBalances
+			receiver = alice
+		}
+
+		sendAssetV2(
+			t, ctxt, cfg.NumAssets, sendType, senderAssets,
+			sender, receiver, bitcoinClient, cfg.TestTimeout,
+		)
+	}
+}
+
+// sendAssetV2 sends a certain amount of assets of a specific type from a sender
+// to a receiver. It will scan the balance of the sender and find a suitable
+// asset to carry out the send, then will dispatch the send and assert its
+// completion.
+func sendAssetV2(t *testing.T, ctx context.Context, numAssets uint64,
+	assetType taprpc.AssetType, assets map[string]*taprpc.AssetBalance,
+	sender, receiver *rpcClient, bitcoinClient *rpcclient.Client,
+	timeout time.Duration) {
+
+	// Look over the sender's balances to see if any asset balance qualifies
+	// for this send.
+	var (
+		assetID []byte
+		balance *taprpc.AssetBalance
+	)
+	for _, v := range assets {
+		if v.Balance >= numAssets &&
+			v.AssetGenesis.AssetType == assetType {
+
+			assetID = v.AssetGenesis.AssetId
+			balance = v
+
+			break
+		}
+	}
+
+	// No balance satisfies the amount of this send, we can skip this round.
+	if assetID == nil {
+		t.Logf("%s could not send %v assets, no available balance",
+			sender.cfg.Name, numAssets)
+
+		return
+	}
+
+	t.Logf("%s sending %v assets to %s", sender.cfg.Name, numAssets,
+		receiver.cfg.Name)
+
+	// Receiver creates the address to receive the assets.
+	addr, err := receiver.NewAddr(ctx, &taprpc.NewAddrRequest{
+		AssetId: assetID,
+		Amt:     numAssets,
+		ProofCourierAddr: fmt.Sprintf(
+			"%s://%s:%d", proof.UniverseRpcCourierType,
+			sender.cfg.Host, sender.cfg.Port,
+		),
+	})
+	require.NoError(t, err)
+
+	t.Logf("%s created address %v", receiver.cfg.Name, addr.String())
+
+	// Sender initiates the send.
+	_, err = sender.SendAsset(ctx, &taprpc.SendAssetRequest{
+		TapAddrs: []string{addr.Encoded},
+	})
+	require.NoError(t, err)
+	t.Logf("%s sent assets to address %v", sender.cfg.Name, addr.String())
+
+	// We assert the receiver detects the spend.
+	itest.AssertAddrEventCustomTimeout(
+		t, receiver, addr, 1, statusDetected, timeout,
+	)
+	t.Logf("%s detected send", receiver.cfg.Name)
+
+	// Mine a block to confirm the transfer.
+	itest.MineBlocks(t, bitcoinClient, 1, 0)
+	t.Log("Mined 1 block")
+
+	// Assert that the transfer is now completed
+	itest.AssertAddrEventCustomTimeout(
+		t, receiver, addr, 1, statusCompleted, timeout,
+	)
+	t.Logf("%s completed send of %v assets", sender.cfg.Name, numAssets)
+
+	// If everything completed correctly, subtract the asset amount from the
+	// sender's asset balance.
+	balance.Balance -= numAssets
+}
+
+// sendAsset sends the given number of assets of the given type from the given
 // node to the other node.
 func sendAssets(t *testing.T, ctx context.Context, numAssets uint64,
 	assetType taprpc.AssetType, send, receive *rpcClient,