itest: minimize use of deprecated ImportProof RPC

With this commit we reduce the number of places we use the old
deprecated ImportProof RPC and also make it very clear that we're using
something deprecated.
Because some very old tests still depend on the proof being inserted
(even if the destination node doesn't have the script key to spend the
assets), completely removing the use of this method will require a
bigger refactor.

Author: guggero

itest/addrs_test.go

@@ -182,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,
 	)
 
@@ -191,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.
@@ -774,7 +773,9 @@ func testUnknownTlvType(t *harnessTest) {
 		require.NoError(t.t, charlie.stop(!*noDelete))
 	}()
 
-	ImportProofFile(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(
@@ -845,7 +846,7 @@ func sendProof(t *harnessTest, src, dst *tapdHarness,
 	genInfo *taprpc.GenesisInfo) {
 
 	proofResp := exportProof(t, src, sendResp, scriptKey, genInfo)
-	ImportProofFile(t, dst, proofResp.RawProofFile, genInfo.GenesisPoint)
+	ImportProofFile(t, dst, proofResp.RawProofFile)
 }
 
 // exportProof manually exports a proof from the given source node for a
@@ -883,7 +884,7 @@ func transferProofUniRPC(t *harnessTest, src, dst *tapdHarness,
 		t.t, src, genInfo.AssetId, scriptKey, outpoint, group,
 	)
 
-	lastProof, err := proofFile.LastProof()
+	lastProof, err := proofFile.RawLastProof()
 	require.NoError(t.t, err)
 
 	return InsertProofIntoUniverse(t.t, dst, lastProof)
@@ -904,7 +905,7 @@ func transferProofNormalExportUniInsert(t *harnessTest, src, dst *tapdHarness,
 	err := f.Decode(bytes.NewReader(proofResp.RawProofFile))
 	require.NoError(t.t, err)
 
-	lastProof, err := f.LastProof()
+	lastProof, err := f.RawLastProof()
 	require.NoError(t.t, err)
 
 	return InsertProofIntoUniverse(t.t, dst, lastProof)

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(

itest/psbt_test.go

@@ -424,14 +424,14 @@ func testPsbtMultiVersionSend(t *harnessTest) {
 
 	numAssets := 1
 	AssertNumAssets(t.t, ctxb, sender, numAssets)
-	firstAsset, _ = ManualMintSimpleAsset(
+	firstAsset, _, _ = ManualMintSimpleAsset(
 		t, t.lndHarness.Bob, sender, commitment.TapCommitmentV0,
 		&firstReq,
 	)
 
 	numAssets += 1
 	AssertNumAssets(t.t, ctxb, sender, numAssets)
-	secondAsset, _ = ManualMintSimpleAsset(
+	secondAsset, _, _ = ManualMintSimpleAsset(
 		t, t.lndHarness.Bob, sender, commitment.TapCommitmentV1,
 		&secondReq,
 	)
@@ -2681,6 +2681,13 @@ func testPsbtLockTimeSend(t *harnessTest) {
 		},
 	}
 
+	// We need to let the wallet of Bob know that we're going to use a
+	// script key with a custom root.
+	_, err = bob.DeclareScriptKey(ctxt, &wrpc.DeclareScriptKeyRequest{
+		ScriptKey: taprpc.MarshalScriptKey(bobAssetScriptKey),
+	})
+	require.NoError(t.t, err)
+
 	fundRespLock := fundPacket(t, alice, tappsbt.ForInteractiveSend(
 		id, fullAmt, bobAssetScriptKey, 0, 0, 0, bobInternalKey,
 		asset.V0, chainParams,
@@ -2889,6 +2896,13 @@ func testPsbtRelativeLockTimeSend(t *harnessTest) {
 		},
 	}
 
+	// We need to let the wallet of Bob know that we're going to use a
+	// script key with a custom root.
+	_, err = bob.DeclareScriptKey(ctxt, &wrpc.DeclareScriptKeyRequest{
+		ScriptKey: taprpc.MarshalScriptKey(bobAssetScriptKey),
+	})
+	require.NoError(t.t, err)
+
 	fundRespLock := fundPacket(t, alice, tappsbt.ForInteractiveSend(
 		id, fullAmt, bobAssetScriptKey, 0, 0, 0, bobInternalKey,
 		asset.V0, chainParams,
@@ -3098,6 +3112,13 @@ func testPsbtRelativeLockTimeSendProofFail(t *harnessTest) {
 		},
 	}
 
+	// We need to let the wallet of Bob know that we're going to use a
+	// script key with a custom root.
+	_, err = bob.DeclareScriptKey(ctxt, &wrpc.DeclareScriptKeyRequest{
+		ScriptKey: taprpc.MarshalScriptKey(bobAssetScriptKey),
+	})
+	require.NoError(t.t, err)
+
 	fundRespLock := fundPacket(t, alice, tappsbt.ForInteractiveSend(
 		id, fullAmt, bobAssetScriptKey, 0, 0, 0, bobInternalKey,
 		asset.V0, chainParams,

itest/utils.go

@@ -564,7 +564,7 @@ func ConfirmBatch(t *testing.T, minerClient *rpcclient.Client,
 
 func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode,
 	tapClient *tapdHarness, commitVersion commitment.TapCommitmentVersion,
-	req *mintrpc.MintAsset) (*taprpc.Asset, *tapdevrpc.ImportProofRequest) {
+	req *mintrpc.MintAsset) (*taprpc.Asset, proof.Blob, string) {
 
 	ctxb := context.Background()
 	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
@@ -725,12 +725,9 @@ func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode,
 	require.NoError(t.t, err)
 	require.True(t.t, proof.IsProofFile(proofBlob))
 
-	importReq := tapdevrpc.ImportProofRequest{
-		ProofFile:    proofBlob,
-		GenesisPoint: genesisOutpoint.String(),
-	}
-	_, err = tapClient.ImportProof(ctxb, &importReq)
-	require.NoError(t.t, err)
+	ImportProofFileDeprecated(
+		t, tapClient, proofBlob, genesisOutpoint.String(),
+	)
 
 	// After proof import, the minted assets should appear in the output of
 	// ListAssets.
@@ -743,7 +740,7 @@ func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode,
 		confEvent.Block.BlockHash(),
 	)
 
-	return mintedAsset[0], &importReq
+	return mintedAsset[0], proofBlob, genesisOutpoint.String()
 }
 
 // ExternalSigRes is a helper struct that holds the signed PSBT and the
@@ -1009,9 +1006,73 @@ func ExportProofFile(t *testing.T, src *tapdHarness, assetID, scriptKey []byte,
 	return proofResp
 }
 
-// ImportProofFile manually imports a proof file using the development only
-// ImportProof RPC.
+// ImportProofFile manually imports a proof file into the given node's universe,
+// then registers the inbound transfer to make the wallet aware of the new asset
+// it received.
 func ImportProofFile(t *harnessTest, dst commands.RpcClientsBundle,
+	rawFile proof.Blob) {
+
+	t.Logf("Importing proof %x", rawFile)
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
+	defer cancel()
+
+	resp, err := dst.UnpackProofFile(ctxt, &taprpc.UnpackProofFileRequest{
+		RawProofFile: rawFile,
+	})
+	require.NoError(t.t, err)
+
+	// Import the proof into the universe.
+	var lastProof *unirpc.AssetProofResponse
+	for _, rawProof := range resp.RawProofs {
+		lastProof = InsertProofIntoUniverse(t.t, dst, rawProof)
+	}
+	require.NotNil(t.t, lastProof)
+	require.NotNil(t.t, lastProof.AssetLeaf)
+	require.NotNil(t.t, lastProof.AssetLeaf.Proof)
+
+	// The proof leaf only contains the actual asset and none of the
+	// taprpc.ChainAsset fields. So for anything related to the actual chain
+	// output, we need to decode the proof in the leaf.
+	decodeResp, err := dst.DecodeProof(ctxt, &taprpc.DecodeProofRequest{
+		RawProof: lastProof.AssetLeaf.Proof,
+	})
+	require.NoError(t.t, err)
+
+	proofAsset := lastProof.AssetLeaf.Asset
+	chainAnchor := decodeResp.DecodedProof.Asset.ChainAnchor
+	op, err := wire.NewOutPointFromString(chainAnchor.AnchorOutpoint)
+	require.NoError(t.t, err)
+
+	var groupKey []byte
+	if proofAsset.AssetGroup != nil {
+		groupKey = proofAsset.AssetGroup.TweakedGroupKey
+	}
+
+	// In order for Bob to expect this incoming transfer, we need to
+	// register it with the internal wallet of Bob.
+	registerResp, err := dst.RegisterTransfer(
+		ctxb, &taprpc.RegisterTransferRequest{
+			AssetId:   proofAsset.AssetGenesis.AssetId,
+			GroupKey:  groupKey,
+			ScriptKey: proofAsset.ScriptKey,
+			Outpoint: &taprpc.OutPoint{
+				Txid:        op.Hash[:],
+				OutputIndex: op.Index,
+			},
+		},
+	)
+	require.NoError(t.t, err)
+	require.Equal(
+		t.t, proofAsset.ScriptKey,
+		registerResp.RegisteredAsset.ScriptKey,
+	)
+}
+
+// ImportProofFileDeprecated manually imports a proof file using the development
+// only ImportProof RPC.
+func ImportProofFileDeprecated(t *harnessTest, dst commands.RpcClientsBundle,
 	rawFile proof.Blob,
 	genesisPoint string) *tapdevrpc.ImportProofResponse {
 
@@ -1114,54 +1175,55 @@ func ExportProofFileFromUniverse(t *testing.T, src commands.RpcClientsBundle,
 // InsertProofIntoUniverse manually inserts a proof into the given node using
 // the universe related InsertProof RPC.
 func InsertProofIntoUniverse(t *testing.T, dst commands.RpcClientsBundle,
-	proof *proof.Proof) *unirpc.AssetProofResponse {
+	proofBytes proof.Blob) *unirpc.AssetProofResponse {
 
 	ctxb := context.Background()
 	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
 	defer cancel()
 
-	var lastProofBytes bytes.Buffer
-	err := proof.Encode(&lastProofBytes)
+	resp, err := dst.DecodeProof(ctxt, &taprpc.DecodeProofRequest{
+		RawProof:          proofBytes,
+		WithMetaReveal:    true,
+		WithPrevWitnesses: true,
+	})
 	require.NoError(t, err)
 
-	proofAsset := proof.Asset
-
-	proofType := universe.ProofTypeTransfer
-	if proofAsset.IsGenesisAsset() {
-		proofType = universe.ProofTypeIssuance
-	}
+	rpcProof := resp.DecodedProof
+	rpcAsset := rpcProof.Asset
+	rpcAnchor := rpcAsset.ChainAnchor
 
 	uniID := universe.Identifier{
-		AssetID:   proofAsset.ID(),
-		ProofType: proofType,
+		ProofType: universe.ProofTypeTransfer,
+	}
+	if rpcProof.GenesisReveal != nil {
+		uniID.ProofType = universe.ProofTypeIssuance
 	}
-	if proofAsset.GroupKey != nil {
-		uniID.GroupKey = &proofAsset.GroupKey.GroupPubKey
+
+	copy(uniID.AssetID[:], rpcAsset.AssetGenesis.AssetId)
+	if rpcAsset.AssetGroup != nil {
+		uniID.GroupKey, err = btcec.ParsePubKey(
+			rpcAsset.AssetGroup.TweakedGroupKey,
+		)
+		require.NoError(t, err)
 	}
 
 	rpcUniID, err := taprootassets.MarshalUniID(uniID)
 	require.NoError(t, err)
 
-	rpcOutPoint := &unirpc.Outpoint{
-		HashStr: proof.AnchorTx.TxHash().String(),
-		Index:   int32(proof.InclusionProof.OutputIndex),
-	}
-
-	scriptKeyBytes := proofAsset.ScriptKey.PubKey.SerializeCompressed()
 	importResp, err := dst.InsertProof(ctxt, &unirpc.AssetProof{
 		Key: &unirpc.UniverseKey{
 			Id: rpcUniID,
 			LeafKey: &unirpc.AssetKey{
-				Outpoint: &unirpc.AssetKey_Op{
-					Op: rpcOutPoint,
+				Outpoint: &unirpc.AssetKey_OpStr{
+					OpStr: rpcAnchor.AnchorOutpoint,
 				},
 				ScriptKey: &unirpc.AssetKey_ScriptKeyBytes{
-					ScriptKeyBytes: scriptKeyBytes,
+					ScriptKeyBytes: rpcAsset.ScriptKey,
 				},
 			},
 		},
 		AssetLeaf: &unirpc.AssetLeaf{
-			Proof: lastProofBytes.Bytes(),
+			Proof: proofBytes,
 		},
 	})
 	require.NoError(t, err)