multi: move inclusion proof feature to FetchSupplyLeaves RPC

The FetchSupplyCommit RPC previously accepted leaf keys and returned
inclusion proofs for those leaves. This feature is now moved to the
FetchSupplyLeaves RPC. The FetchSupplyLeaves endpoint is not served
publicly by the universe server (mostly used in itests), whereas
FetchSupplyCommit is public. Limiting FetchSupplyCommit avoids
on-the-fly inclusion proof generation.

Author: ffranr

cmd/commands/universe.go

@@ -1638,21 +1638,6 @@ var fetchSupplyCommitCmd = cli.Command{
 			Usage:    "the group key of the asset group to fetch",
 			Required: true,
 		},
-		&cli.StringSliceFlag{
-			Name: "issuance_leaf_keys",
-			Usage: "a list of issuance leaf keys to fetch " +
-				"inclusion proofs for",
-		},
-		&cli.StringSliceFlag{
-			Name: "burn_leaf_keys",
-			Usage: "a list of burn leaf keys to fetch inclusion " +
-				"proofs for",
-		},
-		&cli.StringSliceFlag{
-			Name: "ignore_leaf_keys",
-			Usage: "a list of ignore leaf keys to fetch " +
-				"inclusion proofs for",
-		},
 	},
 	Action: fetchSupplyCommit,
 }
@@ -1668,26 +1653,6 @@ func fetchSupplyCommit(ctx *cli.Context) error {
 		},
 	}
 
-	issuanceKeys, err := parseHexStrings(
-		ctx.StringSlice("issuance_leaf_keys"),
-	)
-	if err != nil {
-		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
-	}
-	req.IssuanceLeafKeys = issuanceKeys
-
-	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
-	if err != nil {
-		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
-	}
-	req.BurnLeafKeys = burnKeys
-
-	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
-	if err != nil {
-		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
-	}
-	req.IgnoreLeafKeys = ignoreKeys
-
 	resp, err := client.FetchSupplyCommit(cliCtx, req)
 	if err != nil {
 		return err
@@ -1719,6 +1684,21 @@ var fetchSupplyLeavesCmd = cli.Command{
 			Usage:    "the end of the block height range",
 			Required: true,
 		},
+		&cli.StringSliceFlag{
+			Name: "issuance_leaf_keys",
+			Usage: "a list of issuance leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "burn_leaf_keys",
+			Usage: "a list of burn leaf keys to fetch inclusion " +
+				"proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "ignore_leaf_keys",
+			Usage: "a list of ignore leaf keys to fetch " +
+				"inclusion proofs for",
+		},
 	},
 	Action: fetchSupplyLeaves,
 }
@@ -1736,6 +1716,26 @@ func fetchSupplyLeaves(ctx *cli.Context) error {
 		BlockHeightEnd:   uint32(ctx.Uint64("block_height_end")),
 	}
 
+	issuanceKeys, err := parseHexStrings(
+		ctx.StringSlice("issuance_leaf_keys"),
+	)
+	if err != nil {
+		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
+	}
+	req.IssuanceLeafKeys = issuanceKeys
+
+	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
+	}
+	req.BurnLeafKeys = burnKeys
+
+	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
+	}
+	req.IgnoreLeafKeys = ignoreKeys
+
 	resp, err := client.FetchSupplyLeaves(cliCtx, req)
 	if err != nil {
 		return err

itest/supply_commit_test.go

@@ -230,9 +230,6 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 			GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
 				GroupKeyBytes: groupKeyBytes,
 			},
-			IgnoreLeafKeys: [][]byte{
-				respIgnore.LeafKey,
-			},
 		},
 	)
 	require.Nil(t.t, fetchRespNil)
@@ -266,9 +263,6 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 				GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
 					GroupKeyBytes: groupKeyBytes,
 				},
-				IgnoreLeafKeys: [][]byte{
-					respIgnore.LeafKey,
-				},
 			},
 		)
 		require.NoError(t.t, err)
@@ -308,10 +302,26 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		ignoreRootLeafKey, supplyTreeIgnoreLeafNode,
 	)
 
+	// Now fetch the inclusion proofs using FetchSupplyLeaves instead of
+	// FetchSupplyCommit.
+	t.Log("Fetch supply leaves with inclusion proofs")
+	// nolint: lll
+	fetchLeavesResp, err := t.tapd.FetchSupplyLeaves(
+		ctxb, &unirpc.FetchSupplyLeavesRequest{
+			GroupKey: &unirpc.FetchSupplyLeavesRequest_GroupKeyBytes{
+				GroupKeyBytes: groupKeyBytes,
+			},
+			IgnoreLeafKeys: [][]byte{
+				respIgnore.LeafKey,
+			},
+		},
+	)
+	require.NoError(t.t, err)
+
 	// Unmarshal ignore tree leaf inclusion proof to verify that the
 	// ignored asset outpoint is included in the ignore tree.
-	require.Len(t.t, fetchResp.IgnoreLeafInclusionProofs, 1)
-	inclusionProofBytes := fetchResp.IgnoreLeafInclusionProofs[0]
+	require.Len(t.t, fetchLeavesResp.IgnoreLeafInclusionProofs, 1)
+	inclusionProofBytes := fetchLeavesResp.IgnoreLeafInclusionProofs[0]
 
 	// Verify that the ignore tree root can be computed from the ignore leaf
 	// inclusion proof.

rpcserver.go

@@ -4347,38 +4347,6 @@ func (r *rpcServer) FetchSupplyCommit(ctx context.Context,
 			"root: %w", err)
 	}
 
-	// Get inclusion proofs for any issuance leaf key specified in the
-	// request.
-	issuanceTree := resp.Subtrees[supplycommit.MintTreeType]
-	issuanceInclusionProofs, err := inclusionProofs(
-		ctx, issuanceTree, req.IssuanceLeafKeys,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch issuance tree "+
-			"inclusion proofs: %w", err)
-	}
-
-	// Get inclusion proofs for any burn leaf key specified in the request.
-	burnTree := resp.Subtrees[supplycommit.BurnTreeType]
-	burnInclusionProofs, err := inclusionProofs(
-		ctx, burnTree, req.BurnLeafKeys,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch burn tree "+
-			"inclusion proofs: %w", err)
-	}
-
-	// Get inclusion proofs for any ignore leaf key specified in the
-	// request.
-	ignoreTree := resp.Subtrees[supplycommit.IgnoreTreeType]
-	ignoreInclusionProofs, err := inclusionProofs(
-		ctx, ignoreTree, req.IgnoreLeafKeys,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch ignore tree "+
-			"inclusion proofs: %w", err)
-	}
-
 	// Sanity check: ensure the supply root derived from the supply tree
 	// matches the root provided in the chain commitment.
 	if resp.ChainCommitment.SupplyRoot.NodeHash() !=
@@ -4424,10 +4392,6 @@ func (r *rpcServer) FetchSupplyCommit(ctx context.Context,
 		IssuanceSubtreeRoot: rpcIssuanceSubtreeRoot,
 		BurnSubtreeRoot:     rpcBurnSubtreeRoot,
 		IgnoreSubtreeRoot:   rpcIgnoreSubtreeRoot,
-
-		IssuanceLeafInclusionProofs: issuanceInclusionProofs,
-		BurnLeafInclusionProofs:     burnInclusionProofs,
-		IgnoreLeafInclusionProofs:   ignoreInclusionProofs,
 	}, nil
 }
 
@@ -4477,6 +4441,24 @@ func (r *rpcServer) FetchSupplyLeaves(ctx context.Context,
 		return nil, fmt.Errorf("failed to fetch supply leaves: %w", err)
 	}
 
+	// Check if inclusion proofs are requested.
+	needsInclusionProofs := len(req.IssuanceLeafKeys) > 0 ||
+		len(req.BurnLeafKeys) > 0 || len(req.IgnoreLeafKeys) > 0
+
+	// If inclusion proofs are requested, fetch the subtrees.
+	var subtrees supplycommit.SupplyTrees
+	if needsInclusionProofs {
+		subtreeResult, err := r.cfg.SupplyCommitManager.FetchSubTrees(
+			ctx, assetSpec,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch subtrees for "+
+				"inclusion proofs: %w", err)
+		}
+
+		subtrees = subtreeResult
+	}
+
 	rpcMarshalLeafEntry := func(leafEntry supplycommit.SupplyUpdateEvent) (
 		*unirpc.SupplyLeafEntry, error) {
 
@@ -4568,10 +4550,56 @@ func (r *rpcServer) FetchSupplyLeaves(ctx context.Context,
 		rpcIgnoreLeaves = append(rpcIgnoreLeaves, rpcLeaf)
 	}
 
+	// Generate inclusion proofs if requested.
+	var (
+		issuanceInclusionProofs [][]byte
+		burnInclusionProofs     [][]byte
+		ignoreInclusionProofs   [][]byte
+	)
+
+	if needsInclusionProofs {
+		// Get inclusion proofs for any issuance leaf key specified in
+		// the request.
+		issuanceTree := subtrees[supplycommit.MintTreeType]
+		var err error
+		issuanceInclusionProofs, err = inclusionProofs(
+			ctx, issuanceTree, req.IssuanceLeafKeys,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch issuance tree "+
+				"inclusion proofs: %w", err)
+		}
+
+		// Get inclusion proofs for any burn leaf key specified in the
+		// request.
+		burnTree := subtrees[supplycommit.BurnTreeType]
+		burnInclusionProofs, err = inclusionProofs(
+			ctx, burnTree, req.BurnLeafKeys,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch burn tree "+
+				"inclusion proofs: %w", err)
+		}
+
+		// Get inclusion proofs for any ignore leaf key specified in the
+		// request.
+		ignoreTree := subtrees[supplycommit.IgnoreTreeType]
+		ignoreInclusionProofs, err = inclusionProofs(
+			ctx, ignoreTree, req.IgnoreLeafKeys,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch ignore tree "+
+				"inclusion proofs: %w", err)
+		}
+	}
+
 	return &unirpc.FetchSupplyLeavesResponse{
-		IssuanceLeaves: rpcIssuanceLeaves,
-		BurnLeaves:     rpcBurnLeaves,
-		IgnoreLeaves:   rpcIgnoreLeaves,
+		IssuanceLeaves:              rpcIssuanceLeaves,
+		BurnLeaves:                  rpcBurnLeaves,
+		IgnoreLeaves:                rpcIgnoreLeaves,
+		IssuanceLeafInclusionProofs: issuanceInclusionProofs,
+		BurnLeafInclusionProofs:     burnInclusionProofs,
+		IgnoreLeafInclusionProofs:   ignoreInclusionProofs,
 	}, nil
 }