itest: add createAssetHodlInvoice helper func

Author: Roasbeef

itest/assets_test.go

@@ -838,6 +838,74 @@ func createAssetInvoice(t *testing.T, dstRfqPeer, dst *HarnessNode,
 	return resp.InvoiceResult
 }
 
+type assetHodlInvoice struct {
+	preimage lntypes.Preimage
+	payReq   string
+}
+
+func createAssetHodlInvoice(t *testing.T, dstRfqPeer, dst *HarnessNode,
+	assetAmount uint64, assetID []byte) assetHodlInvoice {
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
+	defer cancel()
+
+	timeoutSeconds := int64(rfq.DefaultInvoiceExpiry.Seconds())
+
+	t.Logf("Asking peer %x for quote to buy assets to receive for "+
+		"invoice over %d units; waiting up to %ds",
+		dstRfqPeer.PubKey[:], assetAmount, timeoutSeconds)
+
+	dstTapd := newTapClient(t, dst)
+
+	// As this is a hodl invoice, we'll also need to create a preimage external
+	// to lnd.
+	var preimage lntypes.Preimage
+	_, err := rand.Read(preimage[:])
+	require.NoError(t, err)
+
+	payHash := preimage.Hash()
+
+	resp, err := dstTapd.AddInvoice(ctxt, &tchrpc.AddInvoiceRequest{
+		AssetId:     assetID,
+		AssetAmount: assetAmount,
+		PeerPubkey:  dstRfqPeer.PubKey[:],
+		InvoiceRequest: &lnrpc.Invoice{
+			Memo: fmt.Sprintf("this is an asset invoice over "+
+				"%d units", assetAmount),
+			Expiry: timeoutSeconds,
+		},
+		HodlInvoice: &tchrpc.HodlInvoice{
+			PaymentHash: payHash[:],
+		},
+	})
+	require.NoError(t, err)
+
+	decodedInvoice, err := dst.DecodePayReq(ctxt, &lnrpc.PayReqString{
+		PayReq: resp.InvoiceResult.PaymentRequest,
+	})
+	require.NoError(t, err)
+
+	rpcRate := resp.AcceptedBuyQuote.AskAssetRate
+	rate, err := rfqrpc.UnmarshalFixedPoint(rpcRate)
+	require.NoError(t, err)
+
+	assetUnits := rfqmath.NewBigIntFixedPoint(assetAmount, 0)
+	numMSats := rfqmath.UnitsToMilliSatoshi(assetUnits, *rate)
+	mSatPerUnit := float64(decodedInvoice.NumMsat) / float64(assetAmount)
+
+	require.EqualValues(t, uint64(numMSats), uint64(decodedInvoice.NumMsat))
+
+	t.Logf("Got quote for %d sats at %v msat/unit from peer %x with SCID "+
+		"%d", decodedInvoice.NumMsat, mSatPerUnit, dstRfqPeer.PubKey[:],
+		resp.AcceptedBuyQuote.Scid)
+
+	return assetHodlInvoice{
+		preimage: preimage,
+		payReq:   resp.InvoiceResult.PaymentRequest,
+	}
+}
+
 func waitForSendEvent(t *testing.T,
 	sendEvents taprpc.TaprootAssets_SubscribeSendEventsClient,
 	expectedState tapfreighter.SendState) {
@@ -1349,6 +1417,16 @@ func assertAssetBalance(t *testing.T, client *tapClient, assetID []byte,
 
 		t.Logf("Failed to assert expected balance of %d, current "+
 			"assets: %v", expectedBalance, toProtoJSON(t, r))
+
+		utxos, err3 := client.ListUtxos(ctxb, &taprpc.ListUtxosRequest{})
+		require.NoError(t, err3)
+
+		t.Logf("Current UTXOs: %v", toProtoJSON(t, utxos))
+
+		t.Fatalf("Failed to assert balance: %v", err)
+	}
+}
+
 // assertSpendableBalance differs from assertAssetBalance in that it asserts
 // that the entire balance is spendable. We consider something spendable if we
 // have a local script key for it.