Merge pull request #1364 from lightninglabs/trustless-swap-uni-rpc

taprpc: Add new taprpc.RegisterTransfer RPC as a safe alternative to devrpc.ImportProof

Author: ffranr

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)

itest/addrs_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 
-	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/wire"
 	tap "github.com/lightninglabs/taproot-assets"
@@ -19,7 +18,6 @@ import (
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	wrpc "github.com/lightninglabs/taproot-assets/taprpc/assetwalletrpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
-	"github.com/lightninglabs/taproot-assets/taprpc/tapdevrpc"
 	unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/lntest/wait"
@@ -184,7 +182,7 @@ func testAddresses(t *harnessTest) {
 		},
 		Amount: 22,
 	}
-	manualAsset, mintProof := ManualMintSimpleAsset(
+	manualAsset, mintProofBlob, mintOP := ManualMintSimpleAsset(
 		t, t.lndHarness.Alice, t.tapd, commitment.TapCommitmentV0, &req,
 	)
 
@@ -193,12 +191,11 @@ func testAddresses(t *harnessTest) {
 	respJSON, err := formatProtoJSON(manualAsset)
 	require.NoError(t.t, err)
 
-	t.Logf("manually minted asset: %s", respJSON)
+	t.Logf("Manually minted asset: %s", respJSON)
 
 	// Import the issuance proof to the second node so we can try to receive
 	// it.
-	_, err = secondTapd.ImportProof(ctxb, mintProof)
-	require.NoError(t.t, err)
+	ImportProofFileDeprecated(t, secondTapd, mintProofBlob, mintOP)
 
 	// Trying to receive the new asset to a version 0 address should
 	// succeed.
@@ -776,7 +773,9 @@ func testUnknownTlvType(t *harnessTest) {
 		require.NoError(t.t, charlie.stop(!*noDelete))
 	}()
 
-	importProof(t, charlie, modifiedBlob, genInfo.GenesisPoint)
+	ImportProofFileDeprecated(
+		t, charlie, modifiedBlob, genInfo.GenesisPoint,
+	)
 
 	// When we export it again, it should have the same TLV types.
 	transferProof2 := exportProof(
@@ -844,10 +843,10 @@ func testUnknownTlvType(t *harnessTest) {
 // using the development only ImportProof RPC on the destination node.
 func sendProof(t *harnessTest, src, dst *tapdHarness,
 	sendResp *taprpc.SendAssetResponse, scriptKey []byte,
-	genInfo *taprpc.GenesisInfo) *tapdevrpc.ImportProofResponse {
+	genInfo *taprpc.GenesisInfo) {
 
 	proofResp := exportProof(t, src, sendResp, scriptKey, genInfo)
-	return importProof(t, dst, proofResp.RawProofFile, genInfo.GenesisPoint)
+	ImportProofFile(t, dst, proofResp.RawProofFile)
 }
 
 // exportProof manually exports a proof from the given source node for a
@@ -856,8 +855,6 @@ func exportProof(t *harnessTest, src *tapdHarness,
 	sendResp *taprpc.SendAssetResponse, scriptKey []byte,
 	genInfo *taprpc.GenesisInfo) *taprpc.ProofFile {
 
-	ctxb := context.Background()
-
 	// We need to find the outpoint of the asset we sent to the address.
 	var outpoint *taprpc.OutPoint
 	for _, out := range sendResp.Transfer.Outputs {
@@ -874,212 +871,44 @@ func exportProof(t *harnessTest, src *tapdHarness,
 		}
 	}
 
-	var proofResp *taprpc.ProofFile
-	waitErr := wait.NoError(func() error {
-		resp, err := src.ExportProof(ctxb, &taprpc.ExportProofRequest{
-			AssetId:   genInfo.AssetId,
-			ScriptKey: scriptKey,
-			Outpoint:  outpoint,
-		})
-		if err != nil {
-			return err
-		}
-
-		proofResp = resp
-		return nil
-	}, defaultWaitTimeout)
-	require.NoError(t.t, waitErr)
-
-	return proofResp
+	return ExportProofFile(t.t, src, genInfo.AssetId, scriptKey, outpoint)
 }
 
-// importProof manually imports a proof using the development only ImportProof
-// RPC.
-func importProof(t *harnessTest, dst *tapdHarness, rawFile []byte,
-	genesisPoint string) *tapdevrpc.ImportProofResponse {
-
-	t.Logf("Importing proof %x", rawFile)
-
-	ctxb := context.Background()
-	importResp, err := dst.ImportProof(ctxb, &tapdevrpc.ImportProofRequest{
-		ProofFile:    rawFile,
-		GenesisPoint: genesisPoint,
-	})
-	require.NoError(t.t, err)
-
-	return importResp
-}
-
-// sendUniProof manually exports a proof from the given source using the
-// universe RPCs and then imports it into the destination node.
-func sendUniProof(t *harnessTest, src, dst *tapdHarness, scriptKey []byte,
-	genInfo *taprpc.GenesisInfo, group *taprpc.AssetGroup,
-	outpoint string) *tapdevrpc.ImportProofResponse {
-
-	ctxb := context.Background()
-	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
-	defer cancel()
-
-	fetchUniProof := func(ctx context.Context,
-		loc proof.Locator) (proof.Blob, error) {
-
-		uniID := universe.Identifier{
-			AssetID: *loc.AssetID,
-		}
-		if loc.GroupKey != nil {
-			uniID.GroupKey = loc.GroupKey
-		}
-
-		rpcUniID, err := tap.MarshalUniID(uniID)
-		require.NoError(t.t, err)
-
-		op := &unirpc.Outpoint{
-			HashStr: loc.OutPoint.Hash.String(),
-			Index:   int32(loc.OutPoint.Index),
-		}
-		scriptKeyBytes := loc.ScriptKey.SerializeCompressed()
-
-		uniProof, err := src.QueryProof(ctx, &unirpc.UniverseKey{
-			Id: rpcUniID,
-			LeafKey: &unirpc.AssetKey{
-				Outpoint: &unirpc.AssetKey_Op{
-					Op: op,
-				},
-				ScriptKey: &unirpc.AssetKey_ScriptKeyBytes{
-					ScriptKeyBytes: scriptKeyBytes,
-				},
-			},
-		})
-		if err != nil {
-			return nil, err
-		}
-
-		return uniProof.AssetLeaf.Proof, nil
-	}
-
-	var assetID asset.ID
-	copy(assetID[:], genInfo.AssetId)
-
-	scriptPubKey, err := btcec.ParsePubKey(scriptKey)
-	require.NoError(t.t, err)
-
-	op, err := wire.NewOutPointFromString(outpoint)
-	require.NoError(t.t, err)
-
-	loc := proof.Locator{
-		AssetID:   &assetID,
-		ScriptKey: *scriptPubKey,
-		OutPoint:  op,
-	}
-
-	if group != nil {
-		groupKey, err := btcec.ParsePubKey(group.TweakedGroupKey)
-		require.NoError(t.t, err)
-
-		loc.GroupKey = groupKey
-	}
+// transferProofUniRPC manually exports a proof from the given source using the
+// universe RPCs and then inserts it into the destination node's universe.
+func transferProofUniRPC(t *harnessTest, src, dst *tapdHarness,
+	scriptKey []byte, genInfo *taprpc.GenesisInfo, group *taprpc.AssetGroup,
+	outpoint string) *unirpc.AssetProofResponse {
 
-	var proofFile *proof.File
-	err = wait.NoError(func() error {
-		proofFile, err = proof.FetchProofProvenance(
-			ctxt, nil, loc, fetchUniProof,
-		)
-		return err
-	}, defaultWaitTimeout)
-	require.NoError(t.t, err)
-
-	var buf bytes.Buffer
-	err = proofFile.Encode(&buf)
-	require.NoError(t.t, err)
-
-	t.Logf("Importing proof %x", buf.Bytes())
+	proofFile := ExportProofFileFromUniverse(
+		t.t, src, genInfo.AssetId, scriptKey, outpoint, group,
+	)
 
-	importResp, err := dst.ImportProof(ctxb, &tapdevrpc.ImportProofRequest{
-		ProofFile:    buf.Bytes(),
-		GenesisPoint: genInfo.GenesisPoint,
-	})
+	lastProof, err := proofFile.RawLastProof()
 	require.NoError(t.t, err)
 
-	return importResp
+	return InsertProofIntoUniverse(t.t, dst, lastProof)
 }
 
-// sendProofUniRPC manually exports a proof from the given source node and
-// imports it using the universe related InsertProof RPC on the destination
-// node.
-func sendProofUniRPC(t *harnessTest, src, dst *tapdHarness, scriptKey []byte,
+// transferProofNormalExportUniInsert manually exports a proof from the given
+// source node and imports it using the universe related InsertProof RPC on the
+// destination node.
+func transferProofNormalExportUniInsert(t *harnessTest, src, dst *tapdHarness,
+	scriptKey []byte,
 	genInfo *taprpc.GenesisInfo) *unirpc.AssetProofResponse {
 
-	ctxb := context.Background()
-
-	var proofResp *taprpc.ProofFile
-	waitErr := wait.NoError(func() error {
-		resp, err := src.ExportProof(ctxb, &taprpc.ExportProofRequest{
-			AssetId:   genInfo.AssetId,
-			ScriptKey: scriptKey,
-		})
-		if err != nil {
-			return err
-		}
-
-		proofResp = resp
-		return nil
-	}, defaultWaitTimeout)
-	require.NoError(t.t, waitErr)
+	proofResp := ExportProofFile(t.t, src, genInfo.AssetId, scriptKey, nil)
 
 	t.Logf("Importing proof %x using InsertProof", proofResp.RawProofFile)
 
 	f := proof.File{}
 	err := f.Decode(bytes.NewReader(proofResp.RawProofFile))
 	require.NoError(t.t, err)
 
-	lastProof, err := f.LastProof()
-	require.NoError(t.t, err)
-
-	var lastProofBytes bytes.Buffer
-	err = lastProof.Encode(&lastProofBytes)
-	require.NoError(t.t, err)
-	asset := lastProof.Asset
-
-	proofType := universe.ProofTypeTransfer
-	if asset.IsGenesisAsset() {
-		proofType = universe.ProofTypeIssuance
-	}
-
-	uniID := universe.Identifier{
-		AssetID:   asset.ID(),
-		ProofType: proofType,
-	}
-	if asset.GroupKey != nil {
-		uniID.GroupKey = &asset.GroupKey.GroupPubKey
-	}
-
-	rpcUniID, err := tap.MarshalUniID(uniID)
-	require.NoError(t.t, err)
-
-	outpoint := &unirpc.Outpoint{
-		HashStr: lastProof.AnchorTx.TxHash().String(),
-		Index:   int32(lastProof.InclusionProof.OutputIndex),
-	}
-
-	importResp, err := dst.InsertProof(ctxb, &unirpc.AssetProof{
-		Key: &unirpc.UniverseKey{
-			Id: rpcUniID,
-			LeafKey: &unirpc.AssetKey{
-				Outpoint: &unirpc.AssetKey_Op{
-					Op: outpoint,
-				},
-				ScriptKey: &unirpc.AssetKey_ScriptKeyBytes{
-					ScriptKeyBytes: scriptKey,
-				},
-			},
-		},
-		AssetLeaf: &unirpc.AssetLeaf{
-			Proof: lastProofBytes.Bytes(),
-		},
-	})
+	lastProof, err := f.RawLastProof()
 	require.NoError(t.t, err)
 
-	return importResp
+	return InsertProofIntoUniverse(t.t, dst, lastProof)
 }
 
 // sendOptions is a struct that holds a SendAssetRequest and an

itest/assets_test.go

@@ -21,7 +21,6 @@ import (
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	wrpc "github.com/lightninglabs/taproot-assets/taprpc/assetwalletrpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
-	"github.com/lightninglabs/taproot-assets/taprpc/tapdevrpc"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/stretchr/testify/require"
@@ -238,11 +237,7 @@ func transferAssetProofs(t *harnessTest, src, dst *tapdHarness,
 		proofFile := AssertAssetProofs(
 			t.t, src, chainClient, existingAsset,
 		)
-		_, err := dst.ImportProof(ctxt, &tapdevrpc.ImportProofRequest{
-			ProofFile:    proofFile,
-			GenesisPoint: gen.GenesisPoint,
-		})
-		require.NoError(t.t, err)
+		ImportProofFileDeprecated(t, dst, proofFile, gen.GenesisPoint)
 	}
 
 	listResp, err := dst.ListAssets(