rpcserver: SendPayment uses groupkey

We have taken care of the groupkey RFQ negotiation in previous commits.
All we need now to support sending a payment over a group of assets, is
to propagate the user specifier groupkey to the corresponding fields.

Author: GeorgeTsagk

rpcserver.go

@@ -7227,13 +7227,28 @@ func (r *rpcServer) SendPayment(req *tchrpc.SendPaymentRequest,
 	pReq := req.PaymentRequest
 	ctx := stream.Context()
 
-	// Do some preliminary checks on the asset ID and make sure we have any
-	// balance for that asset.
-	if len(req.AssetId) != sha256.Size {
-		return fmt.Errorf("asset ID must be 32 bytes")
+	var specifier asset.Specifier
+
+	switch {
+	case len(req.AssetId) > 0 && len(req.GroupKey) > 0:
+		return fmt.Errorf("cannot set both asset id and group key")
+
+	case len(req.AssetId) > 0:
+		if len(req.AssetId) != sha256.Size {
+			return fmt.Errorf("asset ID must be 32 bytes")
+		}
+		var assetID asset.ID
+		copy(assetID[:], req.AssetId)
+		specifier = asset.NewSpecifierFromId(assetID)
+
+	case len(req.GroupKey) > 0:
+		groupKey, err := btcec.ParsePubKey(req.GroupKey)
+		if err != nil {
+			return fmt.Errorf("failed to parse group key: %w",
+				err)
+		}
+		specifier = asset.NewSpecifierFromGroupKey(*groupKey)
 	}
-	var assetID asset.ID
-	copy(assetID[:], req.AssetId)
 
 	// Now that we know we have at least _some_ asset balance, we'll figure
 	// out what kind of payment this is, so we can determine _how many_
@@ -7358,7 +7373,26 @@ func (r *rpcServer) SendPayment(req *tchrpc.SendPaymentRequest,
 			peerPubKey = &parsedKey
 		}
 
-		specifier := asset.NewSpecifierFromId(assetID)
+		var rpcSpecifier rfqrpc.AssetSpecifier
+
+		switch {
+		case specifier.HasId():
+			assetID := specifier.UnwrapIdToPtr()
+			rpcSpecifier = rfqrpc.AssetSpecifier{
+				Id: &rfqrpc.AssetSpecifier_AssetId{
+					AssetId: assetID[:],
+				},
+			}
+
+		case specifier.HasGroupPubKey():
+			groupKey := specifier.UnwrapGroupKeyToPtr()
+			groupKeyBytes := groupKey.SerializeCompressed()
+			rpcSpecifier = rfqrpc.AssetSpecifier{
+				Id: &rfqrpc.AssetSpecifier_GroupKey{
+					GroupKey: groupKeyBytes,
+				},
+			}
+		}
 
 		// We can now query the asset channels we have.
 		assetChan, err := r.rfqChannel(
@@ -7384,14 +7418,10 @@ func (r *rpcServer) SendPayment(req *tchrpc.SendPaymentRequest,
 
 		resp, err := r.AddAssetSellOrder(
 			ctx, &rfqrpc.AddAssetSellOrderRequest{
-				AssetSpecifier: &rfqrpc.AssetSpecifier{
-					Id: &rfqrpc.AssetSpecifier_AssetId{
-						AssetId: assetID[:],
-					},
-				},
-				PaymentMaxAmt: uint64(paymentMaxAmt),
-				Expiry:        uint64(expiry.Unix()),
-				PeerPubKey:    peerPubKey[:],
+				AssetSpecifier: &rpcSpecifier,
+				PaymentMaxAmt:  uint64(paymentMaxAmt),
+				Expiry:         uint64(expiry.Unix()),
+				PeerPubKey:     peerPubKey[:],
 				TimeoutSeconds: uint32(
 					rfq.DefaultTimeout.Seconds(),
 				),
@@ -7474,9 +7504,34 @@ func (r *rpcServer) SendPayment(req *tchrpc.SendPaymentRequest,
 				"for keysend payment")
 		}
 
-		balances := []*rfqmsg.AssetBalance{
-			rfqmsg.NewAssetBalance(assetID, req.AssetAmount),
+		var balances []*rfqmsg.AssetBalance
+
+		switch {
+		case specifier.HasId():
+			balances = []*rfqmsg.AssetBalance{
+				rfqmsg.NewAssetBalance(
+					*specifier.UnwrapIdToPtr(),
+					req.AssetAmount,
+				),
+			}
+
+		case specifier.HasGroupPubKey():
+			groupKey := specifier.UnwrapGroupKeyToPtr()
+			groupHash := sha256.Sum256(
+				groupKey.SerializeCompressed(),
+			)
+
+			// We can't distribute the amount over distinct asset ID
+			// balances, so we provide the total amount under the
+			// dummy asset ID that is produced by hashing the group
+			// key.
+			balances = []*rfqmsg.AssetBalance{
+				rfqmsg.NewAssetBalance(
+					groupHash, req.AssetAmount,
+				),
+			}
 		}
+
 		htlc := rfqmsg.NewHtlc(balances, fn.None[rfqmsg.ID]())
 
 		// We'll now map the HTLC struct into a set of TLV records,