tapdb: fix "mismatch of managed utxo and constructed..." error

Fixes the following error that occurred sometimes:
unable to fund address send: error funding packet: unable to list eligible coins: unable to query commitments: mismatch of managed utxo and constructed tap commitment root

This would happen when we inserted the split _ROOT_ output as a proof
file (instead of going through the transfer flow which didn't have this
issue), because the split commitment root wasn't properly written to
the database in that case.
Which means, not a single itest so far did send out the split root
output to the counterparty as part of an interactive transfer.

This was only discovered after turning the address v2 send flow into an
interactive send, which does allow the split root output to be sent to
the counterparty instead of only using it as the local change output.

Author: guggero

tapdb/assets_common.go

@@ -276,18 +276,32 @@ func upsertAssetsWithGenesis(ctx context.Context, q UpsertAssetStore,
 			continue
 		}
 
+		var (
+			splitCommitmentRootHash  []byte
+			splitCommitmentRootValue sql.NullInt64
+		)
+		if a.SplitCommitmentRoot != nil {
+			splitRootHash := a.SplitCommitmentRoot.NodeHash()
+			splitCommitmentRootHash = splitRootHash[:]
+			splitCommitmentRootValue = sqlInt64(
+				a.SplitCommitmentRoot.NodeSum(),
+			)
+		}
+
 		// With all the dependent data inserted, we can now insert the
 		// base asset information itself.
 		assetIDs[idx], err = q.UpsertAsset(ctx, sqlc.UpsertAssetParams{
-			GenesisID:           genAssetID,
-			Version:             int32(a.Version),
-			ScriptKeyID:         scriptKeyID,
-			AssetGroupWitnessID: groupWitnessID,
-			ScriptVersion:       int32(a.ScriptVersion),
-			Amount:              int64(a.Amount),
-			LockTime:            sqlInt32(a.LockTime),
-			RelativeLockTime:    sqlInt32(a.RelativeLockTime),
-			AnchorUtxoID:        anchorUtxoID,
+			GenesisID:                genAssetID,
+			Version:                  int32(a.Version),
+			ScriptKeyID:              scriptKeyID,
+			AssetGroupWitnessID:      groupWitnessID,
+			ScriptVersion:            int32(a.ScriptVersion),
+			Amount:                   int64(a.Amount),
+			LockTime:                 sqlInt32(a.LockTime),
+			RelativeLockTime:         sqlInt32(a.RelativeLockTime),
+			AnchorUtxoID:             anchorUtxoID,
+			SplitCommitmentRootHash:  splitCommitmentRootHash,
+			SplitCommitmentRootValue: splitCommitmentRootValue,
 		})
 		if err != nil {
 			return 0, nil, fmt.Errorf("unable to insert asset: %w",

tapdb/assets_store.go

@@ -23,6 +23,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
 	"github.com/lightninglabs/taproot-assets/tapfreighter"
 	"github.com/lightninglabs/taproot-assets/tappsbt"
+	"github.com/lightninglabs/taproot-assets/tapsend"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/keychain"
 )
@@ -2343,10 +2344,18 @@ func (a *AssetStore) queryCommitments(ctx context.Context,
 		// Verify that the constructed Taproot Asset commitment matches
 		// the commitment root stored in the managed UTXO.
 		commitmentRoot := tapCommitment.TapscriptRoot(nil)
+
+		tapsend.LogCommitment(
+			"reconstructed input", int(anchorPoint.Index),
+			tapCommitment, &btcec.PublicKey{}, nil, nil,
+		)
+
 		anchorCommitmentRoot := anchorUTXO.TaprootAssetRoot
 		if !bytes.Equal(anchorCommitmentRoot, commitmentRoot[:]) {
-			return nil, fmt.Errorf("mismatch of managed utxo and " +
-				"constructed tap commitment root")
+			return nil, fmt.Errorf("mismatch of managed utxo and "+
+				"constructed tap commitment root, "+
+				"utxoRoot=%x, reconstructedRoot=%x",
+				anchorCommitmentRoot, commitmentRoot[:])
 		}
 
 		anchorPointToCommitment[anchorPoint] = tapCommitment

tapdb/assets_store_test.go

@@ -3247,3 +3247,139 @@ func TestShouldSkipAssetCreation(t *testing.T) {
 		})
 	}
 }
+
+// createTestProofWithAnchor creates an annotated proof with specific anchor
+// index.
+func createTestProofWithAnchor(t *testing.T, testAsset *asset.Asset,
+	anchorIndex uint32) *proof.AnnotatedProof {
+
+	var blockHash chainhash.Hash
+	_, err := rand.Read(blockHash[:])
+	require.NoError(t, err)
+
+	anchorTx := wire.NewMsgTx(2)
+	anchorTx.AddTxIn(&wire.TxIn{})
+
+	// Add enough outputs to cover the requested index
+	for i := uint32(0); i <= anchorIndex; i++ {
+		anchorTx.AddTxOut(&wire.TxOut{
+			PkScript: bytes.Repeat([]byte{0x01}, 34),
+			Value:    10,
+		})
+	}
+
+	assetRoot, err := commitment.NewAssetCommitment(testAsset)
+	require.NoError(t, err)
+
+	commitVersion := test.RandFlip(nil, fn.Ptr(commitment.TapCommitmentV2))
+	taprootAssetRoot, err := commitment.NewTapCommitment(
+		commitVersion, assetRoot,
+	)
+	require.NoError(t, err)
+
+	testProof := randProof(t, testAsset)
+	proofBlob, err := testProof.Bytes()
+	require.NoError(t, err)
+
+	assetID := testAsset.ID()
+	anchorPoint := wire.OutPoint{
+		Hash:  anchorTx.TxHash(),
+		Index: anchorIndex,
+	}
+
+	return &proof.AnnotatedProof{
+		Locator: proof.Locator{
+			AssetID:   &assetID,
+			ScriptKey: *testAsset.ScriptKey.PubKey,
+		},
+		Blob: proofBlob,
+		AssetSnapshot: &proof.AssetSnapshot{
+			Asset:             testAsset,
+			OutPoint:          anchorPoint,
+			AnchorBlockHash:   blockHash,
+			AnchorBlockHeight: uint32(test.RandIntn(1000) + 1),
+			AnchorTxIndex:     test.RandInt[uint32](),
+			AnchorTx:          anchorTx,
+			OutputIndex:       anchorIndex,
+			InternalKey:       test.RandPubKey(t),
+			ScriptRoot:        taprootAssetRoot,
+		},
+	}
+}
+
+// TestUpsertAssetsWithSplitCommitments tests that split commitment data is
+// properly stored and retrieved during asset upsert operations.
+func TestUpsertAssetsWithSplitCommitments(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name           string
+		hasSplitCommit bool
+		splitValue     uint64
+	}{
+		{
+			name:           "asset with split commitment",
+			hasSplitCommit: true,
+			splitValue:     12345,
+		},
+		{
+			name:           "asset without split commitment",
+			hasSplitCommit: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := context.Background()
+			dbHandle := NewDbHandle(t)
+
+			testAsset := randAsset(t)
+
+			var expectedHash mssmt.NodeHash
+			if tc.hasSplitCommit {
+				splitHash := test.RandBytes(32)
+				copy(expectedHash[:], splitHash)
+
+				rootNode := mssmt.NewComputedNode(
+					expectedHash, tc.splitValue,
+				)
+				testAsset.SplitCommitmentRoot = rootNode
+			}
+
+			annotatedProof := createTestProofWithAnchor(
+				t, testAsset, 0,
+			)
+
+			err := dbHandle.AssetStore.ImportProofs(
+				ctx, proof.MockVerifierCtx, false,
+				annotatedProof,
+			)
+			require.NoError(t, err)
+
+			assets, err := dbHandle.AssetStore.FetchAllAssets(
+				ctx, false, false, nil,
+			)
+			require.NoError(t, err)
+			require.Len(t, assets, 1)
+
+			dbAsset := assets[0].Asset
+
+			root := dbAsset.SplitCommitmentRoot
+			if tc.hasSplitCommit {
+				require.NotNil(t, root)
+				gotHash := root.NodeHash()
+				require.Equal(t, expectedHash, gotHash)
+				require.Equal(
+					t, tc.splitValue, root.NodeSum(),
+				)
+			} else {
+				require.Nil(
+					t, root,
+					"Split commitment root should be nil",
+				)
+			}
+		})
+	}
+}

tapdb/sqlc/assets.sql.go

@@ -218,9 +218,10 @@ RETURNING gen_asset_id;
 -- name: UpsertAsset :one
 INSERT INTO assets (
     genesis_id, version, script_key_id, asset_group_witness_id, script_version, 
-    amount, lock_time, relative_lock_time, anchor_utxo_id, spent
+    amount, lock_time, relative_lock_time, anchor_utxo_id, spent,
+    split_commitment_root_hash, split_commitment_root_value
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12
 )
 ON CONFLICT (genesis_id, script_key_id, anchor_utxo_id)
     -- This is a NOP, anchor_utxo_id is one of the unique fields that caused the