multi: make all new txes v3

bhandras · bhandras · commit ca2244584b9b · 2025-10-24T18:06:10.000+02:00
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.
diff --git a/asset/group_key_test.go b/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(
diff --git a/asset/mock.go b/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)
diff --git a/itest/round_trip_send_test.go b/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,
 	}}
diff --git a/itest/utils.go b/itest/utils.go
@@ -632,7 +632,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),
diff --git a/proof/verifier_test.go b/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",
+	)
+}
diff --git a/tapchannel/commitment.go b/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,
diff --git a/tapdb/addrs_test.go b/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(),
diff --git a/tapdb/asset_minting_test.go b/tapdb/asset_minting_test.go
@@ -200,7 +200,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),
diff --git a/tapdb/assets_store.go b/tapdb/assets_store.go
@@ -772,7 +772,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)
@@ -3592,7 +3592,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,
 			))
diff --git a/tapdb/assets_store_test.go b/tapdb/assets_store_test.go
@@ -375,7 +375,7 @@ func TestImportAssetProof(t *testing.T) {
 	// We now add a second proof for the same script key but a different
 	// outpoint and expect that to be stored and retrieved correctly.
 	oldOutpoint := testProof.AssetSnapshot.OutPoint
-	newChainTx := wire.NewMsgTx(2)
+	newChainTx := wire.NewMsgTx(3)
 	newChainTx.TxIn = []*wire.TxIn{{
 		PreviousOutPoint: test.RandOp(t),
 	}}
@@ -1577,7 +1577,7 @@ func TestAssetExportLog(t *testing.T) {
 	require.Len(t, utxos, 1)
 	require.Equal(t, assetGen.anchorPoints[0], utxos[0].OutPoint)
 
-	newAnchorTx := wire.NewMsgTx(2)
+	newAnchorTx := wire.NewMsgTx(3)
 	newAnchorTx.AddTxIn(&wire.TxIn{})
 	newAnchorTx.TxIn[0].SignatureScript = []byte{}
 	newAnchorTx.AddTxOut(&wire.TxOut{
@@ -2377,7 +2377,7 @@ func TestTransferOutputProofDeliveryStatus(t *testing.T) {
 	// of the first transfer output.
 	//
 	// First, we'll generate a new anchor transaction for use in the parcel.
-	newAnchorTx := wire.NewMsgTx(2)
+	newAnchorTx := wire.NewMsgTx(3)
 	newAnchorTx.AddTxIn(&wire.TxIn{})
 	newAnchorTx.TxIn[0].SignatureScript = []byte{}
 	newAnchorTx.AddTxOut(&wire.TxOut{
@@ -2670,7 +2670,7 @@ func TestQueryAssetBurns(t *testing.T) {
 	// of the first transfer output.
 	//
 	// First, we'll generate a new anchor transaction for use in the parcel.
-	newAnchorTx := wire.NewMsgTx(2)
+	newAnchorTx := wire.NewMsgTx(3)
 	newAnchorTx.AddTxIn(&wire.TxIn{})
 	newAnchorTx.TxIn[0].SignatureScript = []byte{}
 	newAnchorTx.AddTxOut(&wire.TxOut{
@@ -3257,7 +3257,7 @@ func createTestProofWithAnchor(t *testing.T, testAsset *asset.Asset,
 	_, err := rand.Read(blockHash[:])
 	require.NoError(t, err)
 
-	anchorTx := wire.NewMsgTx(2)
+	anchorTx := wire.NewMsgTx(3)
 	anchorTx.AddTxIn(&wire.TxIn{})
 
 	// Add enough outputs to cover the requested index
diff --git a/tapdb/sqlutils_test.go b/tapdb/sqlutils_test.go
@@ -76,7 +76,7 @@ func (d *DbHandler) AddRandomAssetProof(t *testing.T) (*asset.Asset,
 	_, 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),
diff --git a/tapdb/supply_commit_test.go b/tapdb/supply_commit_test.go
@@ -114,7 +114,7 @@ func (h *supplyCommitTestHarness) addTestMintingBatch() ([]byte, int64,
 	genesisPointID, err := upsertGenesisPoint(ctx, db, genesisPoint)
 	require.NoError(h.t, err)
 
-	mintingTx := wire.NewMsgTx(2)
+	mintingTx := wire.NewMsgTx(3)
 	mintingTx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: genesisPoint,
 	})
@@ -2238,7 +2238,7 @@ func TestSupplyCommitFetchLatestCommitment(t *testing.T) {
 func randTx(t *testing.T, numOutputs int) *wire.MsgTx {
 	t.Helper()
 
-	tx := wire.NewMsgTx(2)
+	tx := wire.NewMsgTx(3)
 	tx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: test.RandOp(t),
 	})
@@ -2265,7 +2265,7 @@ func TestSupplyCommitMultipleSupplyCommitments(t *testing.T) {
 	// Helper to generate unique transaction data for each commitment
 	genTxData := func() (int64, []byte, []byte) {
 		genesisPoint := test.RandOp(h.t)
-		tx := wire.NewMsgTx(2)
+		tx := wire.NewMsgTx(3)
 		tx.AddTxIn(&wire.TxIn{
 			PreviousOutPoint: genesisPoint,
 		})
@@ -2323,7 +2323,7 @@ func TestSupplySyncerPushLog(t *testing.T) {
 	// TestSupplyCommitMultipleSupplyCommitments.
 	genTxData := func() (int64, []byte, []byte) {
 		genesisPoint := test.RandOp(h.t)
-		tx := wire.NewMsgTx(2)
+		tx := wire.NewMsgTx(3)
 		tx.AddTxIn(&wire.TxIn{
 			PreviousOutPoint: genesisPoint,
 		})
diff --git a/tapdb/universe_test.go b/tapdb/universe_test.go
@@ -1232,7 +1232,7 @@ func TestUpsertSupplyPreCommit(t *testing.T) {
 	// Create test data.
 	groupKey := test.RandPubKey(t)
 	internalKey, _ := test.RandKeyDesc(t)
-	mintingTx := wire.NewMsgTx(2)
+	mintingTx := wire.NewMsgTx(3)
 	mintingTx.AddTxOut(&wire.TxOut{Value: 1000})
 	blockHeight := uint32(100)
 
diff --git a/tapgarden/custodian_test.go b/tapgarden/custodian_test.go
@@ -449,7 +449,7 @@ func randAddrV2(h *custodianHarness, proofCourier url.URL,
 
 func randWalletTx(addr *address.AddrWithKeyInfo) (int, *lndclient.Transaction) {
 	tx := &lndclient.Transaction{
-		Tx:        wire.NewMsgTx(2),
+		Tx:        wire.NewMsgTx(3),
 		Timestamp: time.Now(),
 	}
 	numInputs := rand.Intn(10) + 1
diff --git a/tapgarden/mock.go b/tapgarden/mock.go
@@ -336,7 +336,7 @@ func NewMockWalletAnchor() *MockWalletAnchor {
 
 // NewGenesisTx creates a funded genesis PSBT with the given fee rate.
 func NewGenesisTx(t testing.TB, feeRate chainfee.SatPerKWeight) psbt.Packet {
-	txTemplate := wire.NewMsgTx(2)
+	txTemplate := wire.NewMsgTx(3)
 	txTemplate.AddTxOut(tapsend.CreateDummyOutput())
 	genesisPkt, err := psbt.NewFromUnsignedTx(txTemplate)
 	require.NoError(t, err)
diff --git a/tapgarden/planter.go b/tapgarden/planter.go
@@ -709,7 +709,7 @@ func unfundedAnchorPsbt(preCommitmentTxOut fn.Option[wire.TxOut]) (psbt.Packet,
 	var zero psbt.Packet
 
 	// Construct a template transaction for our minting anchor transaction.
-	txTemplate := wire.NewMsgTx(2)
+	txTemplate := wire.NewMsgTx(3)
 
 	// Add one output to anchor all assets which are being minted.
 	txTemplate.AddTxOut(tapsend.CreateDummyOutput())
diff --git a/tapgarden/re-org_watcher_test.go b/tapgarden/re-org_watcher_test.go
@@ -69,7 +69,7 @@ func newReOrgWatcherHarness(t *testing.T) *reOrgWatcherHarness {
 }
 
 func makeTx() *wire.MsgTx {
-	anchorTx := wire.NewMsgTx(2)
+	anchorTx := wire.NewMsgTx(3)
 	anchorTx.TxOut = []*wire.TxOut{{
 		PkScript: test.RandBytes(32),
 		Value:    100,
diff --git a/tappsbt/encode.go b/tappsbt/encode.go
@@ -48,7 +48,7 @@ type encoderMapping struct {
 // error if the encoding fails.
 func (p *VPacket) EncodeAsPsbt() (*psbt.Packet, error) {
 	unsignedTx := &wire.MsgTx{
-		Version: 2,
+		Version: 3,
 		TxIn:    make([]*wire.TxIn, len(p.Inputs)),
 		TxOut:   make([]*wire.TxOut, len(p.Outputs)),
 	}
diff --git a/tappsbt/testdata/psbt_encoding_generated.json b/tappsbt/testdata/psbt_encoding_generated.json
diff --git a/tapscript/tx.go b/tapscript/tx.go
diff --git a/tapsend/proof_test.go b/tapsend/proof_test.go
diff --git a/tapsend/send.go b/tapsend/send.go
diff --git a/universe/supplycommit/state_machine_test.go b/universe/supplycommit/state_machine_test.go
diff --git a/universe/supplycommit/transitions.go b/universe/supplycommit/transitions.go

Original file line number	Diff line number	Diff line change
`@@ -632,7 +632,7 @@ func ManualMintSimpleAsset(t harnessTest, lndNode node.HarnessNode,`
`632`	`632`	`[]byte{txscript.OP_1, txscript.OP_DATA_32},`
`633`	`633`	`bytes.Repeat([]byte{0x00}, 32)...,`
`634`	`634`	`)`
`635`		`- txTemplate := wire.NewMsgTx(2)`
	`635`	`+ txTemplate := wire.NewMsgTx(3)`
`636`	`636`	`txTemplate.AddTxOut(&wire.TxOut{`
`637`	`637`	`Value: int64(btcutil.Amount(1000)),`
`638`	`638`	`PkScript: bytes.Clone(genesisDummyScript),`
Original file line number	Diff line number	Diff line change
`@@ -1492,7 +1492,7 @@ func CreateSecondLevelHtlcTx(chanState lnwallet.AuxChanState,`
`1492`	`1492`	`func FakeCommitTx(fundingOutpoint wire.OutPoint,`
`1493`	`1493`	`allocations []tapsend.Allocation) (wire.MsgTx, error) {`
`1494`	`1494`
`1495`		`- fakeCommitTx := wire.NewMsgTx(2)`
	`1495`	`+ fakeCommitTx := wire.NewMsgTx(3)`
`1496`	`1496`	`fakeCommitTx.TxIn = []*wire.TxIn{`
`1497`	`1497`	`{`
`1498`	`1498`	`PreviousOutPoint: fundingOutpoint,`
Original file line number	Diff line number	Diff line change
`@@ -772,7 +772,7 @@ func dbAssetsToChainAssets(dbAssets []ConfirmedAsset, witnesses assetWitnesses,`
`772`	`772`	`}`
`773`	`773`	`}`
`774`	`774`
`775`		`- anchorTx := wire.NewMsgTx(2)`
	`775`	`+ anchorTx := wire.NewMsgTx(3)`
`776`	`776`	`err = anchorTx.Deserialize(bytes.NewBuffer(sprout.AnchorTx))`
`777`	`777`	`if err != nil {`
`778`	`778`	`return nil, fmt.Errorf("unable to decode tx: %w", err)`
`@@ -3592,7 +3592,7 @@ func (a *AssetStore) queryParcelsWithFilters(ctx context.Context,`
`3592`	`3592`	`"%w", err)`
`3593`	`3593`	`}`
`3594`	`3594`
`3595`		`- anchorTx := wire.NewMsgTx(2)`
	`3595`	`+ anchorTx := wire.NewMsgTx(3)`
`3596`	`3596`	`err = anchorTx.Deserialize(bytes.NewReader(`
`3597`	`3597`	`dbAnchorTx.RawTx,`
`3598`	`3598`	`))`