taprpc+rpcserver: add group key to DecodeAssetPayReq

Since we support group keys in all other payment related commands, we
now add the same argument for the invoice decoding RPC.

Author: guggero

rpcserver.go

@@ -8584,29 +8584,73 @@ func (r *rpcServer) assetInvoiceAmt(ctx context.Context,
 func (r *rpcServer) DecodeAssetPayReq(ctx context.Context,
 	payReq *tchrpc.AssetPayReq) (*tchrpc.AssetPayReqResponse, error) {
 
+	tapdLog.Debugf("Decoding asset pay req, asset_id=%x, group_key=%x,"+
+		"pay_req=%v", payReq.AssetId, payReq.GroupKey,
+		payReq.PayReqString)
+
 	if r.cfg.PriceOracle == nil {
 		return nil, fmt.Errorf("price oracle is not set")
 	}
 
 	// First, we'll perform some basic input validation.
+	var assetID asset.ID
 	switch {
-	case len(payReq.AssetId) == 0:
-		return nil, fmt.Errorf("asset ID must be specified")
+	case len(payReq.AssetId) == 0 && len(payReq.GroupKey) == 0:
+		return nil, fmt.Errorf("either asset ID or group key must be " +
+			"specified")
 
-	case len(payReq.AssetId) != 32:
+	case len(payReq.AssetId) != 0 && len(payReq.GroupKey) != 0:
+		return nil, fmt.Errorf("cannot set both asset ID and group key")
+
+	case len(payReq.AssetId) != 0 && len(payReq.AssetId) != 32:
 		return nil, fmt.Errorf("asset ID must be 32 bytes, "+
 			"was %d", len(payReq.AssetId))
 
+	case len(payReq.GroupKey) != 0 && len(payReq.GroupKey) != 33 &&
+		len(payReq.GroupKey) != 32:
+
+		return nil, fmt.Errorf("group key must be 32 or 33 bytes, "+
+			"was %d", len(payReq.GroupKey))
+
 	case len(payReq.PayReqString) == 0:
 		return nil, fmt.Errorf("payment request must be specified")
 	}
 
-	var (
-		resp    tchrpc.AssetPayReqResponse
-		assetID asset.ID
-	)
+	// We made sure that only one is set, so let's now use the asset ID
+	// or group key.
+	switch {
+	// The asset ID is easy, we can just copy the bytes.
+	case len(payReq.AssetId) != 0:
+		copy(assetID[:], payReq.AssetId)
+
+	// The group key is a bit more involved. We first need to sync the asset
+	// group, then fetch the leaves that are associated with this group key.
+	// From there, we can look up the asset ID of one of the group's
+	// tranches.
+	case len(payReq.GroupKey) != 0:
+		var (
+			groupKey *btcec.PublicKey
+			err      error
+		)
+		if len(payReq.GroupKey) == 32 {
+			groupKey, err = schnorr.ParsePubKey(payReq.GroupKey)
+		} else {
+			groupKey, err = btcec.ParsePubKey(payReq.GroupKey)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("error parsing group "+
+				"key: %w", err)
+		}
+
+		assetID, err = r.syncAssetGroup(ctx, *groupKey)
+		if err != nil {
+			return nil, fmt.Errorf("error syncing asset group: %w",
+				err)
+		}
 
-	copy(assetID[:], payReq.AssetId)
+		tapdLog.Debugf("Resolved asset ID %v for group key %x",
+			assetID.String(), groupKey.SerializeCompressed())
+	}
 
 	// With the inputs validated, we'll first call out to lnd to decode the
 	// payment request.
@@ -8618,7 +8662,9 @@ func (r *rpcServer) DecodeAssetPayReq(ctx context.Context,
 		return nil, fmt.Errorf("unable to fetch channel: %w", err)
 	}
 
-	resp.PayReq = payReqInfo
+	resp := tchrpc.AssetPayReqResponse{
+		PayReq: payReqInfo,
+	}
 
 	// Next, we'll fetch the information for this asset ID through the addr
 	// book. This'll automatically fetch the asset if needed.
@@ -8628,12 +8674,17 @@ func (r *rpcServer) DecodeAssetPayReq(ctx context.Context,
 			"asset_id=%x: %w", assetID[:], err)
 	}
 
-	resp.GenesisInfo = &taprpc.GenesisInfo{
-		GenesisPoint: assetGroup.FirstPrevOut.String(),
-		AssetType:    taprpc.AssetType(assetGroup.Type),
-		Name:         assetGroup.Tag,
-		MetaHash:     assetGroup.MetaHash[:],
-		AssetId:      assetID[:],
+	// The genesis info makes no sense in the case where we have decoded the
+	// invoice for a group key, since we just pick the first asset ID we
+	// found for a group key.
+	if len(payReq.GroupKey) == 0 {
+		resp.GenesisInfo = &taprpc.GenesisInfo{
+			GenesisPoint: assetGroup.FirstPrevOut.String(),
+			AssetType:    taprpc.AssetType(assetGroup.Type),
+			Name:         assetGroup.Tag,
+			MetaHash:     assetGroup.MetaHash[:],
+			AssetId:      assetID[:],
+		}
 	}
 
 	// If this asset ID belongs to an asset group, then we'll display that
@@ -8693,6 +8744,97 @@ func (r *rpcServer) DecodeAssetPayReq(ctx context.Context,
 	return &resp, nil
 }
 
+// syncAssetGroup checks if we already know any asset leaves associated with
+// this group key. If not, it will sync the asset group and return the asset
+// ID of the first leaf found. If there are no leaves found after syncing, an
+// error is returned.
+func (r *rpcServer) syncAssetGroup(ctx context.Context,
+	groupKey btcec.PublicKey) (asset.ID, error) {
+
+	// We first check if we already know any asset leaves associated with
+	// this group key.
+	leaf := fn.NewRight[asset.ID](groupKey)
+	leaves, err := r.cfg.Multiverse.FetchLeaves(
+		ctx, []universe.MultiverseLeafDesc{leaf},
+		universe.ProofTypeIssuance,
+	)
+	if err != nil {
+		return asset.ID{}, fmt.Errorf("error fetching leaves: %w", err)
+	}
+
+	tapdLog.Tracef("Found %d leaves for group key %x",
+		len(leaves), groupKey.SerializeCompressed())
+
+	// If there are no leaves, then we need to sync the asset group.
+	if len(leaves) == 0 {
+		tapdLog.Debugf("No leaves found for group key %x, "+
+			"syncing asset group", groupKey.SerializeCompressed())
+		err = r.cfg.AddrBook.SyncAssetGroup(ctx, groupKey)
+		if err != nil {
+			return asset.ID{}, fmt.Errorf("error syncing asset "+
+				"group: %w", err)
+		}
+
+		// Now we can try again.
+		leaves, err = r.cfg.Multiverse.FetchLeaves(
+			ctx, []universe.MultiverseLeafDesc{leaf},
+			universe.ProofTypeIssuance,
+		)
+		if err != nil {
+			return asset.ID{}, fmt.Errorf("error fetching leaves: "+
+				"%w", err)
+		}
+
+		tapdLog.Tracef("Found %d leaves for group key %x",
+			len(leaves), groupKey.SerializeCompressed())
+
+		if len(leaves) == 0 {
+			return asset.ID{}, fmt.Errorf("no asset leaves found "+
+				"for group %x after sync",
+				groupKey.SerializeCompressed())
+		}
+	}
+
+	// Since we know we have at least one leaf, we can just take leaf ID and
+	// query the keys with it. We just need one so we can fetch the actual
+	// proof to find out the asset ID. We don't really care about the order,
+	// so we just use the natural database order.
+	leafID := leaves[0]
+	leafKeys, err := r.cfg.Multiverse.UniverseLeafKeys(
+		ctx, universe.UniverseLeafKeysQuery{
+			Id:    leafID.ID,
+			Limit: 1,
+		},
+	)
+	if err != nil {
+		return asset.ID{}, fmt.Errorf("error fetching leaf keys: %w",
+			err)
+	}
+
+	// We know we have a leaf, so this shouldn't happen.
+	if len(leafKeys) != 1 {
+		return asset.ID{}, fmt.Errorf("expected 1 leaf key, got %d",
+			len(leafKeys))
+	}
+
+	proofs, err := r.cfg.Multiverse.FetchProofLeaf(
+		ctx, leafID.ID, leafKeys[0],
+	)
+	if err != nil {
+		return asset.ID{}, fmt.Errorf("error fetching proof leaf: %w",
+			err)
+	}
+
+	// We should have a proof for the asset ID now.
+	if len(proofs) != 1 {
+		return asset.ID{}, fmt.Errorf("expected 1 proof, got %d",
+			len(proofs))
+	}
+
+	// We can now extract the asset ID from the proof.
+	return proofs[0].Leaf.ID(), nil
+}
+
 // RegisterTransfer informs the daemon about a new inbound transfer that has
 // happened. This is used for interactive transfers where no TAP address is
 // involved and the recipient is aware of the transfer through an out-of-band