multi: make all new txes v3

This commit changes all new Bitcoin transactions from version 2 to
version 3 (TRUC - Topologically Restricted Until Confirmed) as defined
in BIP 431. Version 3 transactions provide better fee-bumping and
pinning protection, which is beneficial for Taproot Assets anchor
transactions.

Author: bhandras

asset/group_key_test.go

@@ -333,7 +333,7 @@ func TestNonSpendableLeafScript(t *testing.T) {
 
 			// Finally, we'll make the dummy spend transaction, and
 			// the output script that we'll attempt to spend.
-			spendTx := wire.NewMsgTx(1)
+			spendTx := wire.NewMsgTx(3)
 			spendTx.AddTxIn(&wire.TxIn{})
 
 			leafScript, err := txscript.PayToTaprootScript(

asset/mock.go

@@ -313,6 +313,11 @@ func virtualGenesisTx(newAsset *Asset) (*wire.MsgTx, error) {
 
 	// With our single input and output mapped, we're ready to construct our
 	// virtual transaction.
+	//
+	// IMPORTANT: The virtual transaction version must remain at v2 for
+	// backwards compatibility. Changing the version would invalidate all
+	// existing asset witness signatures. Only the anchor (real Bitcoin)
+	// transactions use v3.
 	virtualTx := wire.NewMsgTx(2)
 	virtualTx.AddTxIn(txIn)
 	virtualTx.AddTxOut(txOut)

itest/round_trip_send_test.go

@@ -163,7 +163,7 @@ func testRoundTripSend(t *harnessTest) {
 	estimatedWeight := estimator.Weight()
 	requiredFee := feeRate.FeeForWeight(estimatedWeight)
 
-	tx := wire.NewMsgTx(2)
+	tx := wire.NewMsgTx(3)
 	tx.TxIn = []*wire.TxIn{{
 		PreviousOutPoint: *outpoint,
 	}}

itest/utils.go

@@ -635,7 +635,7 @@ func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode,
 		[]byte{txscript.OP_1, txscript.OP_DATA_32},
 		bytes.Repeat([]byte{0x00}, 32)...,
 	)
-	txTemplate := wire.NewMsgTx(2)
+	txTemplate := wire.NewMsgTx(3)
 	txTemplate.AddTxOut(&wire.TxOut{
 		Value:    int64(btcutil.Amount(1000)),
 		PkScript: bytes.Clone(genesisDummyScript),

proof/proof_test.go

@@ -213,7 +213,7 @@ func TestProofTaprootOutputScript(t *testing.T) {
 
 	// Build a minimal block with a single transaction so RandProof can
 	// anchor the proof.
-	tx := wire.NewMsgTx(2)
+	tx := wire.NewMsgTx(3)
 	tx.AddTxOut(&wire.TxOut{Value: 1})
 	block := wire.MsgBlock{
 		Transactions: []*wire.MsgTx{tx},

proof/verifier_test.go

@@ -1,7 +1,11 @@
 package proof
 
 import (
+	"bytes"
+	"encoding/hex"
+	"os"
 	"slices"
+	"strings"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -155,7 +159,7 @@ func makeV0InclusionProof(t *testing.T, opts ...createProofOpt) ([]*Proof,
 
 	internalKey := test.RandPubKey(t)
 
-	anchorTx := wire.NewMsgTx(2)
+	anchorTx := wire.NewMsgTx(3)
 	anchorTx.TxOut = make([]*wire.TxOut, len(tapCommitments))
 
 	indexes := maps.Keys(tapCommitments)
@@ -1157,3 +1161,53 @@ func TestVerifyV1ExclusionProof(t *testing.T) {
 		})
 	}
 }
+
+// TestTransactionVersionInProofSystem verifies that the current codebase
+// creates v3 transactions.
+func TestTransactionVersionInProofSystem(t *testing.T) {
+	t.Parallel()
+
+	proofs, _ := makeV0InclusionProof(t)
+	require.Len(t, proofs, 1)
+	proof := proofs[0]
+
+	require.Equal(t, int32(3), proof.AnchorTx.Version,
+		"Post-commit b3562461: all new transactions should be v3")
+}
+
+// TestBackwardsCompatibilityWithExistingProofs tests that existing proof files
+// (which contain v2 transactions) can still be loaded and verified by the
+// current v3-enabled codebase.
+func TestBackwardsCompatibilityWithExistingProofs(t *testing.T) {
+	t.Parallel()
+
+	const fileName = "testdata/proof-file.hex"
+
+	// Load the existing proof file (created pre-v3).
+	proofHex, err := os.ReadFile(fileName)
+	require.NoError(t, err, "Failed to load %s", fileName)
+
+	proofBytes, err := hex.DecodeString(
+		strings.TrimSpace(string(proofHex)),
+	)
+	require.NoError(t, err)
+
+	// Decode the proof file.
+	var proofFile File
+	err = proofFile.Decode(bytes.NewReader(proofBytes))
+	require.NoError(t, err, "v3-enabled code must decode existing proofs")
+
+	// Get the last proof from the file.
+	lastProof, err := proofFile.LastProof()
+	require.NoError(t, err)
+
+	t.Logf("Proof file %s uses tx version: %d",
+		fileName, lastProof.AnchorTx.Version)
+
+	require.Equal(t, int32(2), lastProof.AnchorTx.Version)
+
+	_, err = lastProof.verifyExclusionProofs()
+	require.NoError(
+		t, err, "v3-enabled code must verify existing v2 proofs",
+	)
+}

tapchannel/commitment.go

@@ -1492,7 +1492,7 @@ func CreateSecondLevelHtlcTx(chanState lnwallet.AuxChanState,
 func FakeCommitTx(fundingOutpoint wire.OutPoint,
 	allocations []*tapsend.Allocation) (*wire.MsgTx, error) {
 
-	fakeCommitTx := wire.NewMsgTx(2)
+	fakeCommitTx := wire.NewMsgTx(3)
 	fakeCommitTx.TxIn = []*wire.TxIn{
 		{
 			PreviousOutPoint: fundingOutpoint,

tapdb/addrs_test.go

@@ -47,7 +47,7 @@ func confirmTx(tx *lndclient.Transaction) {
 
 func randWalletTx() *lndclient.Transaction {
 	tx := &lndclient.Transaction{
-		Tx:          wire.NewMsgTx(2),
+		Tx:          wire.NewMsgTx(3),
 		Timestamp:   time.Now(),
 		BlockHeight: rand.Int31n(700_000),
 		BlockHash:   test.RandHash().String(),

tapdb/asset_minting_test.go

@@ -201,7 +201,7 @@ func addRandomManagedUTXO(t *testing.T, ctx context.Context,
 	_, err = rand.Read(blockHash[:])
 	require.NoError(t, err)
 
-	anchorTx := wire.NewMsgTx(2)
+	anchorTx := wire.NewMsgTx(3)
 	anchorTx.AddTxIn(&wire.TxIn{})
 	anchorTx.AddTxOut(&wire.TxOut{
 		PkScript: bytes.Repeat([]byte{0x01}, 34),

tapdb/assets_store.go

@@ -781,7 +781,7 @@ func dbAssetsToChainAssets(dbAssets []ConfirmedAsset, witnesses assetWitnesses,
 			}
 		}
 
-		anchorTx := wire.NewMsgTx(2)
+		anchorTx := wire.NewMsgTx(3)
 		err = anchorTx.Deserialize(bytes.NewBuffer(sprout.AnchorTx))
 		if err != nil {
 			return nil, fmt.Errorf("unable to decode tx: %w", err)
@@ -3765,7 +3765,7 @@ func (a *AssetStore) queryParcelsWithFilters(ctx context.Context,
 					"%w", err)
 			}
 
-			anchorTx := wire.NewMsgTx(2)
+			anchorTx := wire.NewMsgTx(3)
 			err = anchorTx.Deserialize(bytes.NewReader(
 				dbAnchorTx.RawTx,
 			))