itest: add grouped asset multi tranche test

Author: guggero

itest/assets_test.go

@@ -290,6 +290,142 @@ func createTestAssetNetwork(t *harnessTest, net *NetworkHarness, charlieTap,
 	return chanPointCD, chanPointDY, chanPointEF
 }
 
+func createTestAssetNetworkGroupKey(ctx context.Context, t *harnessTest,
+	net *NetworkHarness, charlieTap, daveTap, erinTap, fabiaTap,
+	universeTap *tapClient, mintedAssets []*taprpc.Asset, assetSendAmount,
+	charlieFundingAmount, erinFundingAmount uint64,
+	pushSat int64) (*lnrpc.ChannelPoint, *lnrpc.ChannelPoint) {
+
+	var groupKey []byte
+	for _, mintedAsset := range mintedAssets {
+		require.NotNil(t.t, mintedAsset.AssetGroup)
+
+		if groupKey == nil {
+			groupKey = mintedAsset.AssetGroup.TweakedGroupKey
+
+			continue
+		}
+
+		require.Equal(
+			t.t, groupKey, mintedAsset.AssetGroup.TweakedGroupKey,
+		)
+	}
+
+	// We need to send some assets to Erin, so he can fund an asset channel
+	// with Fabia.
+	sendAssetsEqualAmounts(
+		ctx, t, erinTap, charlieTap, universeTap, mintedAssets,
+		assetSendAmount/2, 0,
+	)
+
+	t.Logf("Opening asset channels...")
+
+	// The first channel we create has a push amount, so Charlie can receive
+	// payments immediately and not run into the channel reserve issue.
+	fundRespCD, err := charlieTap.FundChannel(
+		ctx, &tchrpc.FundChannelRequest{
+			AssetAmount:        charlieFundingAmount,
+			GroupKey:           groupKey,
+			PeerPubkey:         daveTap.node.PubKey[:],
+			FeeRateSatPerVbyte: 5,
+			PushSat:            pushSat,
+		},
+	)
+	require.NoError(t.t, err)
+	t.Logf("Funded channel between Charlie and Dave: %v", fundRespCD)
+
+	fundRespEF, err := erinTap.FundChannel(
+		ctx, &tchrpc.FundChannelRequest{
+			AssetAmount:        erinFundingAmount,
+			GroupKey:           groupKey,
+			PeerPubkey:         fabiaTap.node.PubKey[:],
+			FeeRateSatPerVbyte: 5,
+			PushSat:            pushSat,
+		},
+	)
+	require.NoError(t.t, err)
+	t.Logf("Funded channel between Erin and Fabia: %v", fundRespEF)
+
+	// Make sure the pending channel shows up in the list and has the
+	// custom records set as JSON.
+	assertPendingChannels(
+		t.t, charlieTap.node, mintedAssets[1], 1, charlieFundingAmount,
+		0,
+	)
+	assertPendingChannels(
+		t.t, erinTap.node, mintedAssets[0], 1, erinFundingAmount/2, 0,
+	)
+	assertPendingChannels(
+		t.t, erinTap.node, mintedAssets[1], 1, erinFundingAmount/2, 0,
+	)
+
+	// Now that we've looked at the pending channels, let's actually confirm
+	// all three of them.
+	mineBlocks(t, net, 6, 2)
+
+	chanPointCD := &lnrpc.ChannelPoint{
+		OutputIndex: uint32(fundRespCD.OutputIndex),
+		FundingTxid: &lnrpc.ChannelPoint_FundingTxidStr{
+			FundingTxidStr: fundRespCD.Txid,
+		},
+	}
+	chanPointEF := &lnrpc.ChannelPoint{
+		OutputIndex: uint32(fundRespEF.OutputIndex),
+		FundingTxid: &lnrpc.ChannelPoint_FundingTxidStr{
+			FundingTxidStr: fundRespEF.Txid,
+		},
+	}
+
+	return chanPointCD, chanPointEF
+}
+
+func sendAssetsEqualAmounts(ctx context.Context, t *harnessTest,
+	recipient, sender, universe *tapClient, mintedAssets []*taprpc.Asset,
+	assetSendAmount uint64, previousSends uint64) {
+
+	numTranches := uint64(len(mintedAssets))
+	for idx, mintedAsset := range mintedAssets {
+		assetID := mintedAsset.AssetGenesis.AssetId
+		trancheAmount := assetSendAmount / numTranches
+		recipientAddr, err := recipient.NewAddr(
+			ctx, &taprpc.NewAddrRequest{
+				Amt:     trancheAmount,
+				AssetId: assetID,
+				ProofCourierAddr: fmt.Sprintf(
+					"%s://%s", proof.UniverseRpcCourierType,
+					universe.node.Cfg.LitAddr(),
+				),
+			},
+		)
+		require.NoError(t.t, err)
+
+		t.Logf("Sending %v asset units to %s...", trancheAmount,
+			recipient.node.Cfg.Name)
+
+		// We assume that we sent the same size in a previous send.
+		totalSent := trancheAmount + (previousSends * trancheAmount)
+
+		// Send the assets to recipient.
+		itest.AssertAddrCreated(
+			t.t, recipient, mintedAsset, recipientAddr,
+		)
+		sendResp, err := sender.SendAsset(ctx, &taprpc.SendAssetRequest{
+			TapAddrs: []string{recipientAddr.Encoded},
+		})
+		require.NoError(t.t, err)
+		itest.ConfirmAndAssertOutboundTransfer(
+			t.t, t.lndHarness.Miner.Client, sender, sendResp,
+			assetID,
+			[]uint64{mintedAsset.Amount - totalSent, trancheAmount},
+			int(previousSends*numTranches)+idx,
+			int(previousSends*numTranches)+idx+1,
+		)
+		itest.AssertNonInteractiveRecvComplete(
+			t.t, recipient, int(previousSends*numTranches)+idx+1,
+		)
+	}
+}
+
 func assertNumAssetUTXOs(t *testing.T, tapdClient *tapClient,
 	numUTXOs int) *taprpc.ListUtxosResponse {
 
@@ -472,10 +608,13 @@ func assertPendingChannels(t *testing.T, node *HarnessNode,
 		pendingChan.Channel.CustomChannelData, &pendingJSON,
 	)
 	require.NoError(t, err)
-	require.Len(t, pendingJSON.Assets, 1)
+	require.GreaterOrEqual(t, len(pendingJSON.Assets), 1)
 
 	require.NotZero(t, pendingJSON.Assets[0].Capacity)
 
+	pendingFormatted, _ := json.MarshalIndent(pendingJSON, "", "  ")
+	t.Logf("Pending channel: %v", string(pendingFormatted))
+
 	// Check the decimal display of the channel funding blob. If no explicit
 	// value was set, we assume and expect the value of 0.
 	var expectedDecimalDisplay uint8
@@ -493,9 +632,7 @@ func assertPendingChannels(t *testing.T, node *HarnessNode,
 	// Check the balance of the pending channel.
 	assetID := mintedAsset.AssetGenesis.AssetId
 	pendingLocalBalance, pendingRemoteBalance, _, _ :=
-		getAssetChannelBalance(
-			t, node, assetID, true,
-		)
+		getAssetChannelBalance(t, node, [][]byte{assetID}, true)
 	require.EqualValues(t, localSum, pendingLocalBalance)
 	require.EqualValues(t, remoteSum, pendingRemoteBalance)
 }
@@ -621,7 +758,7 @@ func getChannelCustomData(src, dst *HarnessNode) (*rfqmsg.JsonAssetChanInfo,
 	return &assetData.Assets[0], nil
 }
 
-func getAssetChannelBalance(t *testing.T, node *HarnessNode, assetID []byte,
+func getAssetChannelBalance(t *testing.T, node *HarnessNode, assetIDs [][]byte,
 	pending bool) (uint64, uint64, uint64, uint64) {
 
 	ctxb := context.Background()
@@ -642,9 +779,19 @@ func getAssetChannelBalance(t *testing.T, node *HarnessNode, assetID []byte,
 		balances = assetBalance.PendingChannels
 	}
 
+	idMatch := func(assetIDString string) bool {
+		for _, groupedID := range assetIDs {
+			if assetIDString == hex.EncodeToString(groupedID) {
+				return true
+			}
+		}
+
+		return false
+	}
+
 	var localSum, remoteSum uint64
 	for assetIDString := range balances {
-		if assetIDString != hex.EncodeToString(assetID) {
+		if !idMatch(assetIDString) {
 			continue
 		}
 
@@ -2017,8 +2164,27 @@ func logBalance(t *testing.T, nodes []*HarnessNode, assetID []byte,
 	time.Sleep(time.Millisecond * 250)
 
 	for _, node := range nodes {
-		local, remote, localSat, remoteSat :=
-			getAssetChannelBalance(t, node, assetID, false)
+		local, remote, localSat, remoteSat := getAssetChannelBalance(
+			t, node, [][]byte{assetID}, false,
+		)
+
+		t.Logf("%-7s balance: local=%-9d remote=%-9d, localSat=%-9d, "+
+			"remoteSat=%-9d (%v)", node.Cfg.Name, local, remote,
+			localSat, remoteSat, occasion)
+	}
+}
+
+func logBalanceGroup(t *testing.T, nodes []*HarnessNode, assetIDs [][]byte,
+	occasion string) {
+
+	t.Helper()
+
+	time.Sleep(time.Millisecond * 250)
+
+	for _, node := range nodes {
+		local, remote, localSat, remoteSat := getAssetChannelBalance(
+			t, node, assetIDs, false,
+		)
 
 		t.Logf("%-7s balance: local=%-9d remote=%-9d, localSat=%-9d, "+
 			"remoteSat=%-9d (%v)", node.Cfg.Name, local, remote,

itest/litd_custom_channels_test.go

@@ -1140,6 +1140,133 @@ func testCustomChannelsGroupedAsset(ctx context.Context, net *NetworkHarness,
 	assertAssetBalance(t.t, fabiaTap, assetID, fabiaAssetBalance)
 }
 
+func testCustomChannelsGroupedAssetTranches(ctx context.Context,
+	net *NetworkHarness, t *harnessTest) {
+
+	lndArgs := slices.Clone(lndArgsTemplate)
+	litdArgs := slices.Clone(litdArgsTemplate)
+
+	// Explicitly set the proof courier as Zane (now has no other role
+	// other than proof shuffling), otherwise a hashmail courier will be
+	// used. For the funding transaction, we're just posting it and don't
+	// expect a true receiver.
+	zane, err := net.NewNode(
+		t.t, "Zane", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	litdArgs = append(litdArgs, fmt.Sprintf(
+		"--taproot-assets.proofcourieraddr=%s://%s",
+		proof.UniverseRpcCourierType, zane.Cfg.LitAddr(),
+	))
+
+	// The topology we are going for looks like the following:
+	//
+	// Charlie  --[assets]-->  Dave  --[sats]-->  Erin  --[assets]-->  Fabia
+	//
+	// With [assets] being a custom channel and [sats] being a normal, BTC
+	// only channel.
+	charlie, err := net.NewNode(
+		t.t, "Charlie", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	dave, err := net.NewNode(t.t, "Dave", lndArgs, false, true, litdArgs...)
+	require.NoError(t.t, err)
+	erin, err := net.NewNode(t.t, "Erin", lndArgs, false, true, litdArgs...)
+	require.NoError(t.t, err)
+	fabia, err := net.NewNode(
+		t.t, "Fabia", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	nodes := []*HarnessNode{charlie, dave, erin, fabia}
+	connectAllNodes(t.t, net, nodes)
+	fundAllNodes(t.t, net, nodes)
+
+	// Create the normal channel between Dave and Erin.
+	t.Logf("Opening normal channel between Dave and Erin...")
+	channelOp := openChannelAndAssert(
+		t, net, dave, erin, lntest.OpenChannelParams{
+			Amt:         5_000_000,
+			SatPerVByte: 5,
+		},
+	)
+	defer closeChannelAndAssert(t, net, dave, channelOp, false)
+
+	// This is the only public channel, we need everyone to be aware of it.
+	assertChannelKnown(t.t, charlie, channelOp)
+	assertChannelKnown(t.t, fabia, channelOp)
+
+	universeTap := newTapClient(t.t, zane)
+	charlieTap := newTapClient(t.t, charlie)
+	daveTap := newTapClient(t.t, dave)
+	erinTap := newTapClient(t.t, erin)
+	fabiaTap := newTapClient(t.t, fabia)
+
+	groupAssetReq := itest.CopyRequest(&mintrpc.MintAssetRequest{
+		Asset: itestAsset,
+	})
+	groupAssetReq.Asset.NewGroupedAsset = true
+
+	// Mint the asset tranches 1 and 2 on Charlie and sync all nodes to
+	// Charlie as the universe.
+	mintedAssetsT1 := itest.MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner.Client, charlieTap,
+		[]*mintrpc.MintAssetRequest{groupAssetReq},
+	)
+	centsT1 := mintedAssetsT1[0]
+	assetID1 := centsT1.AssetGenesis.AssetId
+	groupKey := centsT1.GetAssetGroup().GetTweakedGroupKey()
+
+	groupAssetReq = itest.CopyRequest(&mintrpc.MintAssetRequest{
+		Asset: itestAsset,
+	})
+	groupAssetReq.Asset.GroupedAsset = true
+	groupAssetReq.Asset.GroupKey = groupKey
+	groupAssetReq.Asset.Name = "itest-asset-cents-tranche-2"
+
+	mintedAssetsT2 := itest.MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner.Client, charlieTap,
+		[]*mintrpc.MintAssetRequest{groupAssetReq},
+	)
+	centsT2 := mintedAssetsT2[0]
+	assetID2 := centsT2.AssetGenesis.AssetId
+
+	t.Logf("Minted lightning cents tranche 1 (%x) and 2 (%x) for group "+
+		"key %x, syncing universes...", assetID1, assetID2, groupKey)
+	syncUniverses(t.t, charlieTap, dave, erin, fabia)
+	t.Logf("Universes synced between all nodes, distributing assets...")
+
+	chanPointCD, chanPointEF := createTestAssetNetworkGroupKey(
+		ctx, t, net, charlieTap, daveTap, erinTap, fabiaTap,
+		universeTap, []*taprpc.Asset{centsT1, centsT2}, startAmount,
+		fundingAmount, fundingAmount, DefaultPushSat,
+	)
+
+	t.Logf("Created channels %v and %v", chanPointCD, chanPointEF)
+
+	// We now send some assets over the channels to test the functionality.
+	// Print initial channel balances.
+	groupIDs := [][]byte{assetID1, assetID2}
+	logBalanceGroup(t.t, nodes, groupIDs, "initial")
+
+	// ------------
+	// Test case 1: Send a direct keysend payment from Charlie to Dave.
+	// ------------
+	const keySendAmount = 100
+	sendAssetKeySendPayment(
+		t.t, charlie, dave, keySendAmount, assetID1, fn.None[int64](),
+	)
+	logBalanceGroup(t.t, nodes, groupIDs, "after keysend")
+
+	t.Logf("Closing Charlie -> Dave channel")
+	closeAssetChannelAndAssert(
+		t, net, charlie, dave, chanPointCD, assetID1, groupKey,
+		universeTap, noOpCoOpCloseBalanceCheck,
+	)
+}
+
 // testCustomChannelsForceClose tests a force close scenario after both parties
 // have an active asset balance.
 func testCustomChannelsForceClose(ctx context.Context, net *NetworkHarness,

itest/litd_test_list_on_test.go

@@ -36,6 +36,10 @@ var allTestCases = []*testCase{
 		name: "test custom channels grouped asset",
 		test: testCustomChannelsGroupedAsset,
 	},
+	{
+		name: "test custom channels grouped asset tranches",
+		test: testCustomChannelsGroupedAssetTranches,
+	},
 	{
 		name: "test custom channels force close",
 		test: testCustomChannelsForceClose,