multi: add new UnpackProofFile RPC and cli counterpart

To allow RPC users to convert from a single proof file to individual raw
proofs without needing to use Golang code, we create a new
UnpackProofFile RPC method that just does the decode/parse.
This will be useful to convert from a file as it can be exported by the
ExportProof RPC to individual proofs that are required for importing
into the universe InsertProof RPC.

Author: guggero

cmd/commands/proofs.go

@@ -22,6 +22,7 @@ var proofCommands = []cli.Command{
 		Subcommands: []cli.Command{
 			verifyProofCommand,
 			decodeProofCommand,
+			unpackProofFileCommand,
 			exportProofCommand,
 			proveOwnershipCommand,
 			verifyOwnershipCommand,
@@ -145,7 +146,56 @@ func decodeProof(ctx *cli.Context) error {
 
 	resp, err := client.DecodeProof(ctxc, req)
 	if err != nil {
-		return fmt.Errorf("unable to verify file: %w", err)
+		return fmt.Errorf("unable to decode file: %w", err)
+	}
+
+	printRespJSON(resp)
+	return nil
+}
+
+var unpackProofFileCommand = cli.Command{
+	Name:      "unpack",
+	ShortName: "u",
+	Usage: "unpack a Taproot Asset proof file into individual raw " +
+		"proofs",
+	Description: `
+	Unpacks a taproot asset proof file that contains the full provenance of
+	an asset into its individual raw proofs, in the order they appear in the
+	proof file.
+`,
+	Flags: []cli.Flag{
+		cli.StringFlag{
+			Name: proofPathName,
+			Usage: "the path to the proof file on disk; use the " +
+				"dash character (-) to read from stdin instead",
+		},
+	},
+	Action: unpackProofFile,
+}
+
+func unpackProofFile(ctx *cli.Context) error {
+	ctxc := getContext()
+	client, cleanUp := getClient(ctx)
+	defer cleanUp()
+
+	if !ctx.IsSet(proofPathName) {
+		_ = cli.ShowCommandHelp(ctx, "unpack")
+		return nil
+	}
+
+	filePath := lncfg.CleanAndExpandPath(ctx.String(proofPathName))
+	rawFile, err := readFile(filePath)
+	if err != nil {
+		return fmt.Errorf("unable to read proof file: %w", err)
+	}
+
+	resp, err := client.UnpackProofFile(
+		ctxc, &taprpc.UnpackProofFileRequest{
+			RawProofFile: rawFile,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("unable to unpack file: %w", err)
 	}
 
 	printRespJSON(resp)

perms/perms.go

@@ -64,6 +64,10 @@ var (
 			Entity: "proofs",
 			Action: "read",
 		}},
+		"/taprpc.TaprootAssets/UnpackProofFile": {{
+			Entity: "proofs",
+			Action: "read",
+		}},
 		"/taprpc.TaprootAssets/ExportProof": {{
 			Entity: "proofs",
 			Action: "read",

rpcserver.go

@@ -1717,6 +1717,32 @@ func (r *rpcServer) DecodeProof(ctx context.Context,
 	}, nil
 }
 
+// UnpackProofFile unpacks a proof file into a list of the individual raw
+// proofs in the proof chain.
+func (r *rpcServer) UnpackProofFile(_ context.Context,
+	req *taprpc.UnpackProofFileRequest) (*taprpc.UnpackProofFileResponse,
+	error) {
+
+	blob := proof.Blob(req.RawProofFile)
+	file, err := blob.AsFile()
+	if err != nil {
+		return nil, fmt.Errorf("unable to decode proof file: %w", err)
+	}
+
+	proofBlobs := make([][]byte, file.NumProofs())
+	for i := 0; i < file.NumProofs(); i++ {
+		proofBlobs[i], err = file.RawProofAt(uint32(i))
+		if err != nil {
+			return nil, fmt.Errorf("unable to extract proof: %w",
+				err)
+		}
+	}
+
+	return &taprpc.UnpackProofFileResponse{
+		RawProofs: proofBlobs,
+	}, nil
+}
+
 // marshalProof turns a transition proof into an RPC DecodedProof.
 func (r *rpcServer) marshalProof(ctx context.Context, p *proof.Proof,
 	withPrevWitnesses, withMetaReveal bool) (*taprpc.DecodedProof, error) {