tapdb: fetch altLeaves during input coin selection

Author: jharveyb

tapdb/assets_store.go

@@ -1409,30 +1409,9 @@ func (a *AssetStore) FetchProof(ctx context.Context,
 
 	readOpts := NewAssetStoreReadTx()
 	dbErr := a.db.ExecTx(ctx, &readOpts, func(q ActiveAssetsStore) error {
-		assetProofs, err := q.FetchAssetProof(ctx, args)
-		if err != nil {
-			return fmt.Errorf("unable to fetch asset proof: %w",
-				err)
-		}
-
-		switch {
-		// We have no proof for this script key.
-		case len(assetProofs) == 0:
-			return proof.ErrProofNotFound
-
-		// If the query without the outpoint returns exactly one proof
-		// then we're fine. If there actually are multiple proofs, we
-		// require the user to specify the outpoint as well.
-		case len(assetProofs) == 1:
-			diskProof = assetProofs[0].ProofFile
-
-			return nil
-
-		// User needs to specify the outpoint as well, since we have
-		// multiple proofs for this script key.
-		default:
-			return proof.ErrMultipleProofs
-		}
+		var err error
+		diskProof, err = fetchProof(ctx, q, args)
+		return err
 	})
 	switch {
 	case errors.Is(dbErr, sql.ErrNoRows):
@@ -1444,6 +1423,34 @@ func (a *AssetStore) FetchProof(ctx context.Context,
 	return diskProof, nil
 }
 
+// fetchProof is a wrapper around the FetchAssetProof query that enforces that
+// a proof is only returned if exactly one matching proof was found.
+func fetchProof(ctx context.Context, q ActiveAssetsStore,
+	args sqlc.FetchAssetProofParams) (proof.Blob, error) {
+
+	assetProofs, err := q.FetchAssetProof(ctx, args)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch asset proof: %w", err)
+	}
+
+	switch {
+	// We have no proof for this script key.
+	case len(assetProofs) == 0:
+		return nil, proof.ErrProofNotFound
+
+	// If the query without the outpoint returns exactly one proof
+	// then we're fine. If there actually are multiple proofs, we
+	// require the user to specify the outpoint as well.
+	case len(assetProofs) == 1:
+		return assetProofs[0].ProofFile, nil
+
+	// User needs to specify the outpoint as well, since we have
+	// multiple proofs for this script key.
+	default:
+		return nil, proof.ErrMultipleProofs
+	}
+}
+
 // locatorToProofQuery turns a proof locator into a FetchAssetProof query
 // struct.
 func locatorToProofQuery(locator proof.Locator) (FetchAssetProof, error) {
@@ -2084,8 +2091,12 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 		chainAnchorToAssets = make(
 			map[wire.OutPoint][]*asset.ChainAsset,
 		)
-		anchorPoints = make(map[wire.OutPoint]AnchorPoint)
-		err          error
+		anchorPoints    = make(map[wire.OutPoint]AnchorPoint)
+		anchorAltLeaves = make(
+			map[wire.OutPoint][]asset.AltLeaf[asset.Asset],
+		)
+		matchingAssetProofs = make(map[wire.OutPoint]proof.Blob)
+		err                 error
 	)
 
 	readOpts := NewAssetStoreReadTx()
@@ -2145,6 +2156,31 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 			}
 
 			anchorPoints[anchorPoint] = anchorUTXO
+
+			// TODO(jhb): replace full proof fetch with
+			// outpoint -> alt leaf table / index
+			// We also need to fetch the input proof here, in order
+			// to fetch any committed alt leaves.
+			assetLoc := proof.Locator{
+				AssetID:   fn.Ptr(matchingAsset.ID()),
+				ScriptKey: *matchingAsset.ScriptKey.PubKey,
+				OutPoint:  &matchingAsset.AnchorOutpoint,
+			}
+			proofArgs, err := locatorToProofQuery(assetLoc)
+			if err != nil {
+				return err
+			}
+
+			var assetProof proof.Blob
+			assetProof, err = fetchProof(ctx, q, proofArgs)
+			switch {
+			case errors.Is(err, sql.ErrNoRows):
+				return proof.ErrProofNotFound
+			case err != nil:
+				return err
+			}
+
+			matchingAssetProofs[anchorPoint] = assetProof
 		}
 
 		return nil
@@ -2153,6 +2189,17 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 		return nil, dbErr
 	}
 
+	for anchorPoint, rawProof := range matchingAssetProofs {
+		lastProof, err := rawProof.AsSingleProof()
+		if err != nil {
+			return nil, err
+		}
+
+		anchorAltLeaves[anchorPoint] = append(
+			anchorAltLeaves[anchorPoint], lastProof.AltLeaves...,
+		)
+	}
+
 	// Our final query wants the complete Taproot Asset commitment for each
 	// of the managed UTXOs. Some of the assets that match our query might
 	// actually be in the same Taproot Asset commitment, so we'll collect
@@ -2164,6 +2211,7 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 		anchorPoint := anchorPoint
 		anchorUTXO := anchorPoints[anchorPoint]
 		anchoredAssets := chainAnchorToAssets[anchorPoint]
+		anchoredAltLeaves := anchorAltLeaves[anchorPoint]
 
 		// Fetch the asset leaves from each chain asset, and then
 		// build a Taproot Asset commitment from this set of assets.
@@ -2199,6 +2247,13 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 			return nil, err
 		}
 
+		// The reconstructed commitment must also include any alt leaves
+		// included in the original commitment.
+		err = tapCommitment.MergeAltLeaves(anchoredAltLeaves)
+		if err != nil {
+			return nil, err
+		}
+
 		// Verify that the constructed Taproot Asset commitment matches
 		// the commitment root stored in the managed UTXO.
 		commitmentRoot := tapCommitment.TapscriptRoot(nil)

tapdb/assets_store_test.go

@@ -618,7 +618,28 @@ func (a *assetGenerator) genAssets(t *testing.T, assetStore *AssetStore,
 		height := a.anchorPointsToHeights[desc.anchorPoint]
 		tapCommitment := anchorPointsToTapCommitments[desc.anchorPoint]
 
-		err := assetStore.importAssetFromProof(
+		// Encode a minimal proof so we have a valid proof blob to
+		// store.
+		assetProof := proof.Proof{}
+		assetProof.AnchorTx = *anchorPoint
+		assetProof.BlockHeight = height
+
+		txMerkleProof, err := proof.NewTxMerkleProof(
+			[]*wire.MsgTx{anchorPoint}, 0,
+		)
+		require.NoError(t, err)
+
+		assetProof.TxMerkleProof = *txMerkleProof
+		assetProof.Asset = *newAsset
+		assetProof.InclusionProof = proof.TaprootProof{
+			OutputIndex: 0,
+			InternalKey: test.RandPubKey(t),
+		}
+
+		proofBlob, err := proof.EncodeAsProofFile(&assetProof)
+		require.NoError(t, err)
+
+		err = assetStore.importAssetFromProof(
 			ctx, assetStore.db, &proof.AnnotatedProof{
 				AssetSnapshot: &proof.AssetSnapshot{
 					AnchorTx:          anchorPoint,
@@ -627,7 +648,7 @@ func (a *assetGenerator) genAssets(t *testing.T, assetStore *AssetStore,
 					ScriptRoot:        tapCommitment,
 					AnchorBlockHeight: height,
 				},
-				Blob: bytes.Repeat([]byte{1}, 100),
+				Blob: proofBlob,
 			},
 		)
 		require.NoError(t, err)

tapdb/sqlutils_test.go

@@ -56,6 +56,7 @@ func (d *DbHandler) AddRandomAssetProof(t *testing.T) (*asset.Asset,
 	// Next, we'll make a new random asset that also has a few inputs with
 	// dummy witness information.
 	testAsset := randAsset(t)
+	testAltLeaves := asset.ToAltLeaves(asset.RandAltLeaves(t, true))
 
 	assetRoot, err := commitment.NewAssetCommitment(testAsset)
 	require.NoError(t, err)
@@ -66,6 +67,9 @@ func (d *DbHandler) AddRandomAssetProof(t *testing.T) (*asset.Asset,
 	)
 	require.NoError(t, err)
 
+	err = taprootAssetRoot.MergeAltLeaves(testAltLeaves)
+	require.NoError(t, err)
+
 	// With our asset created, we can now create the AnnotatedProof we use
 	// to import assets into the database.
 	var blockHash chainhash.Hash
@@ -87,6 +91,7 @@ func (d *DbHandler) AddRandomAssetProof(t *testing.T) (*asset.Asset,
 
 	// Generate a random proof and encode it into a proof blob.
 	testProof := randProof(t, testAsset)
+	testProof.AltLeaves = testAltLeaves
 
 	var proofBlobBuffer bytes.Buffer
 	err = testProof.Encode(&proofBlobBuffer)

tapdb/universe_test.go

@@ -184,6 +184,7 @@ func randProof(t *testing.T, argAsset *asset.Asset) *proof.Proof {
 		InclusionProof: proof.TaprootProof{
 			InternalKey: test.RandPubKey(t),
 		},
+		AltLeaves: asset.ToAltLeaves(asset.RandAltLeaves(t, true)),
 	}
 }