cmd: add --group_key CLI flag to all channel commands

Author: guggero

cmd/litcli/ln.go

@@ -7,9 +7,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"strconv"
 
-	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/rfq"
 	"github.com/lightninglabs/taproot-assets/rfqmath"
 	"github.com/lightninglabs/taproot-assets/taprpc"
@@ -83,8 +81,16 @@ var fundChannelCommand = cli.Command{
 				"channel.",
 		},
 		cli.StringFlag{
-			Name:  "asset_id",
-			Usage: "The asset ID to commit to the channel.",
+			Name: "asset_id",
+			Usage: "The asset ID to commit to the channel; " +
+				"cannot be used at the same time as " +
+				"--group_key",
+		},
+		cli.StringFlag{
+			Name: "group_key",
+			Usage: "The group key to use for selecting assets to " +
+				"commit to the channel; cannot be used at " +
+				"the same time as --asset_id",
 		},
 	},
 	Action: fundChannel,
@@ -106,9 +112,9 @@ func fundChannel(c *cli.Context) error {
 		return fmt.Errorf("error fetching assets: %w", err)
 	}
 
-	assetIDBytes, err := hex.DecodeString(c.String("asset_id"))
+	assetIDBytes, groupKeyBytes, err := parseAssetIdentifier(c)
 	if err != nil {
-		return fmt.Errorf("error hex decoding asset ID: %w", err)
+		return fmt.Errorf("unable to parse asset identifier: %w", err)
 	}
 
 	requestedAmount := c.Uint64("asset_amount")
@@ -149,6 +155,7 @@ func fundChannel(c *cli.Context) error {
 		ctx, &tchrpc.FundChannelRequest{
 			AssetAmount:        requestedAmount,
 			AssetId:            assetIDBytes,
+			GroupKey:           groupKeyBytes,
 			PeerPubkey:         nodePubBytes,
 			FeeRateSatPerVbyte: uint32(c.Uint64("sat_per_vbyte")),
 			PushSat:            c.Int64("push_amt"),
@@ -167,7 +174,15 @@ var (
 	assetIDFlag = cli.StringFlag{
 		Name: "asset_id",
 		Usage: "the asset ID of the asset to use when sending " +
-			"payments with assets",
+			"payments with assets; cannot be used at the same " +
+			"time as --group_key",
+	}
+
+	groupKeyFlag = cli.StringFlag{
+		Name: "group_key",
+		Usage: "the group key of the asset to use when sending " +
+			"payments with assets; cannot be used at the same " +
+			"time as --asset_id",
 	}
 
 	assetAmountFlag = cli.Uint64Flag{
@@ -288,11 +303,12 @@ var sendPaymentCommand = cli.Command{
 
 	Note that this will only work in concert with the --keysend argument.
 	`,
-	ArgsUsage: commands.SendPaymentCommand.ArgsUsage + " --asset_id=X " +
-		"--asset_amount=Y [--rfq_peer_pubkey=Z]",
+	ArgsUsage: commands.SendPaymentCommand.ArgsUsage + " [--asset_id=X " +
+		" | --group_key=X] --asset_amount=Y [--rfq_peer_pubkey=Z] " +
+		"[--allow_overpay]",
 	Flags: append(
-		commands.SendPaymentCommand.Flags, assetIDFlag, assetAmountFlag,
-		rfqPeerPubKeyFlag, allowOverpayFlag,
+		commands.SendPaymentCommand.Flags, assetIDFlag, groupKeyFlag,
+		assetAmountFlag, rfqPeerPubKeyFlag, allowOverpayFlag,
 	),
 	Action: sendPayment,
 }
@@ -322,18 +338,15 @@ func sendPayment(cliCtx *cli.Context) error {
 	defer cleanup()
 
 	switch {
-	case !cliCtx.IsSet(assetIDFlag.Name):
-		return fmt.Errorf("the --asset_id flag must be set")
 	case !cliCtx.IsSet("keysend"):
 		return fmt.Errorf("the --keysend flag must be set")
 	case !cliCtx.IsSet(assetAmountFlag.Name):
 		return fmt.Errorf("--asset_amount must be set")
 	}
 
-	assetIDStr := cliCtx.String(assetIDFlag.Name)
-	assetIDBytes, err := hex.DecodeString(assetIDStr)
+	assetIDBytes, groupKeyBytes, err := parseAssetIdentifier(cliCtx)
 	if err != nil {
-		return fmt.Errorf("unable to decode assetID: %v", err)
+		return fmt.Errorf("unable to parse asset identifier: %w", err)
 	}
 
 	assetAmountToSend := cliCtx.Uint64(assetAmountFlag.Name)
@@ -363,7 +376,9 @@ func sendPayment(cliCtx *cli.Context) error {
 			"is instead: %v", len(destNode))
 	}
 
-	rfqPeerKey, err := hex.DecodeString(cliCtx.String(rfqPeerPubKeyFlag.Name))
+	rfqPeerKey, err := hex.DecodeString(
+		cliCtx.String(rfqPeerPubKeyFlag.Name),
+	)
 	if err != nil {
 		return fmt.Errorf("unable to decode RFQ peer public key: "+
 			"%w", err)
@@ -412,6 +427,7 @@ func sendPayment(cliCtx *cli.Context) error {
 			stream, err := tchrpcClient.SendPayment(
 				ctx, &tchrpc.SendPaymentRequest{
 					AssetId:        assetIDBytes,
+					GroupKey:       groupKeyBytes,
 					AssetAmount:    assetAmountToSend,
 					PeerPubkey:     rfqPeerKey,
 					PaymentRequest: req,
@@ -437,17 +453,18 @@ var payInvoiceCommand = cli.Command{
 	This command attempts to pay an invoice using an asset channel as the
 	source of the payment. The asset ID of the channel must be specified
 	using the --asset_id flag.
+
+	This command is a shortcut for 'sendpayment --pay_req='.
 	`,
-	ArgsUsage: "pay_req --asset_id=X",
+	ArgsUsage: "pay_req [--asset_id=X | --group_key=X] " +
+		"[--rfq_peer_pubkey=y] [--allow_overpay]",
 	Flags: append(commands.PaymentFlags(),
 		cli.Int64Flag{
 			Name: "amt",
 			Usage: "(optional) number of satoshis to fulfill the " +
 				"invoice",
 		},
-		assetIDFlag,
-		rfqPeerPubKeyFlag,
-		allowOverpayFlag,
+		assetIDFlag, groupKeyFlag, rfqPeerPubKeyFlag, allowOverpayFlag,
 	),
 	Action: payInvoice,
 }
@@ -486,15 +503,9 @@ func payInvoice(cli *cli.Context) error {
 		return err
 	}
 
-	if !cli.IsSet(assetIDFlag.Name) {
-		return fmt.Errorf("the --asset_id flag must be set")
-	}
-
-	assetIDStr := cli.String(assetIDFlag.Name)
-
-	assetIDBytes, err := hex.DecodeString(assetIDStr)
+	assetIDBytes, groupKeyBytes, err := parseAssetIdentifier(cli)
 	if err != nil {
-		return fmt.Errorf("unable to decode assetID: %v", err)
+		return fmt.Errorf("unable to parse asset identifier: %w", err)
 	}
 
 	rfqPeerKey, err := hex.DecodeString(cli.String(rfqPeerPubKeyFlag.Name))
@@ -521,6 +532,7 @@ func payInvoice(cli *cli.Context) error {
 			stream, err := tchrpcClient.SendPayment(
 				ctx, &tchrpc.SendPaymentRequest{
 					AssetId:        assetIDBytes,
+					GroupKey:       groupKeyBytes,
 					PeerPubkey:     rfqPeerKey,
 					PaymentRequest: req,
 					AllowOverpay:   allowOverpay,
@@ -546,12 +558,19 @@ var addInvoiceCommand = cli.Command{
 	Add a new invoice, expressing intent for a future payment, received in
 	Taproot Assets.
 	`,
-	ArgsUsage: "asset_id asset_amount",
+	ArgsUsage: "[--asset_id=X | --group_key=X] --asset_amount=Y " +
+		"[--rfq_peer_pubkey=Z] ",
 	Flags: append(
 		commands.AddInvoiceCommand.Flags,
 		cli.StringFlag{
-			Name:  "asset_id",
-			Usage: "the asset ID of the asset to receive",
+			Name: "asset_id",
+			Usage: "the asset ID of the asset to receive; cannot " +
+				"be used at the same time as --group_key",
+		},
+		cli.StringFlag{
+			Name: "group_key",
+			Usage: "the group key of the asset to receive; " +
+				"cannot be used at the same time as --asset_id",
 		},
 		cli.Uint64Flag{
 			Name:  "asset_amount",
@@ -570,36 +589,15 @@ var addInvoiceCommand = cli.Command{
 }
 
 func addInvoice(cli *cli.Context) error {
-	args := cli.Args()
 	ctx := getContext()
 
-	var assetIDStr string
-	switch {
-	case cli.IsSet("asset_id"):
-		assetIDStr = cli.String("asset_id")
-	case args.Present():
-		assetIDStr = args.First()
-		args = args.Tail()
-	default:
-		return fmt.Errorf("asset_id argument missing")
-	}
-
 	var (
-		assetAmount uint64
+		assetAmount = cli.Uint64("asset_amount")
 		preimage    []byte
 		descHash    []byte
 		err         error
 	)
-	switch {
-	case cli.IsSet("asset_amount"):
-		assetAmount = cli.Uint64("asset_amount")
-	case args.Present():
-		assetAmount, err = strconv.ParseUint(args.First(), 10, 64)
-		if err != nil {
-			return fmt.Errorf("unable to parse asset amount %w",
-				err)
-		}
-	default:
+	if assetAmount == 0 {
 		return fmt.Errorf("asset_amount argument missing")
 	}
 
@@ -620,14 +618,11 @@ func addInvoice(cli *cli.Context) error {
 		expirySeconds = cli.Int64("expiry")
 	}
 
-	assetIDBytes, err := hex.DecodeString(assetIDStr)
+	assetIDBytes, groupKeyBytes, err := parseAssetIdentifier(cli)
 	if err != nil {
-		return fmt.Errorf("unable to decode assetID: %v", err)
+		return fmt.Errorf("unable to parse asset identifier: %w", err)
 	}
 
-	var assetID asset.ID
-	copy(assetID[:], assetIDBytes)
-
 	rfqPeerKey, err := hex.DecodeString(cli.String(rfqPeerPubKeyFlag.Name))
 	if err != nil {
 		return fmt.Errorf("unable to decode RFQ peer public key: "+
@@ -643,6 +638,7 @@ func addInvoice(cli *cli.Context) error {
 	channelsClient := tchrpc.NewTaprootAssetChannelsClient(tapdConn)
 	resp, err := channelsClient.AddInvoice(ctx, &tchrpc.AddInvoiceRequest{
 		AssetId:     assetIDBytes,
+		GroupKey:    groupKeyBytes,
 		AssetAmount: assetAmount,
 		PeerPubkey:  rfqPeerKey,
 		InvoiceRequest: &lnrpc.Invoice{
@@ -678,33 +674,29 @@ var decodeAssetInvoiceCommand = cli.Command{
 	Other information such as the decimal display of an asset, and the asset
 	group information (if applicable) are also shown.
 	`,
-	ArgsUsage: "--pay_req=X --asset_id=X",
+	ArgsUsage: "--pay_req=X [--asset_id=X | --group_key=X]",
 	Flags: []cli.Flag{
 		cli.StringFlag{
 			Name:  "pay_req",
 			Usage: "a zpay32 encoded payment request to fulfill",
 		},
-		assetIDFlag,
+		assetIDFlag, groupKeyFlag,
 	},
 	Action: decodeAssetInvoice,
 }
 
 func decodeAssetInvoice(cli *cli.Context) error {
 	ctx := getContext()
 
-	switch {
-	case !cli.IsSet("pay_req"):
+	if !cli.IsSet("pay_req") {
 		return fmt.Errorf("pay_req argument missing")
-	case !cli.IsSet(assetIDFlag.Name):
-		return fmt.Errorf("the --asset_id flag must be set")
 	}
 
 	payReq := cli.String("pay_req")
 
-	assetIDStr := cli.String(assetIDFlag.Name)
-	assetIDBytes, err := hex.DecodeString(assetIDStr)
+	assetIDBytes, groupKeyBytes, err := parseAssetIdentifier(cli)
 	if err != nil {
-		return fmt.Errorf("unable to decode assetID: %v", err)
+		return fmt.Errorf("unable to parse asset identifier: %w", err)
 	}
 
 	tapdConn, cleanup, err := connectSuperMacClient(ctx, cli)
@@ -716,6 +708,7 @@ func decodeAssetInvoice(cli *cli.Context) error {
 	channelsClient := tchrpc.NewTaprootAssetChannelsClient(tapdConn)
 	resp, err := channelsClient.DecodeAssetPayReq(ctx, &tchrpc.AssetPayReq{
 		AssetId:      assetIDBytes,
+		GroupKey:     groupKeyBytes,
 		PayReqString: payReq,
 	})
 	if err != nil {
@@ -726,3 +719,40 @@ func decodeAssetInvoice(cli *cli.Context) error {
 
 	return nil
 }
+
+// parseAssetIdentifier parses either the asset ID or group key from the command
+// line arguments.
+func parseAssetIdentifier(cli *cli.Context) ([]byte, []byte, error) {
+	if !cli.IsSet(assetIDFlag.Name) && !cli.IsSet(groupKeyFlag.Name) {
+		return nil, nil, fmt.Errorf("either the --asset_id or " +
+			"--group_key flag must be set")
+	}
+
+	var (
+		assetIDBytes  []byte
+		groupKeyBytes []byte
+		err           error
+	)
+	if cli.IsSet("asset_id") {
+		assetIDBytes, err = hex.DecodeString(cli.String("asset_id"))
+		if err != nil {
+			return nil, nil, fmt.Errorf("error hex decoding asset "+
+				"ID: %w", err)
+		}
+	}
+
+	if cli.IsSet("group_key") {
+		groupKeyBytes, err = hex.DecodeString(cli.String("group_key"))
+		if err != nil {
+			return nil, nil, fmt.Errorf("error hex decoding group "+
+				"key: %w", err)
+		}
+	}
+
+	if len(assetIDBytes) == 0 && len(groupKeyBytes) == 0 {
+		return nil, nil, fmt.Errorf("only one of --asset_id and " +
+			"--group_key can be set")
+	}
+
+	return assetIDBytes, groupKeyBytes, nil
+}