perf: streaming TxHash and block-level scratch buffer for deserialization

[icellan]

Summary

Two optimizations targeting block deserialization and transaction hashing, measured against a real 3.64 GB testnet block (28,672 txs, block 1681787).

1. Streaming TxHash (eliminates per-tx buffer allocation)

MsgTx.TxHash() previously serialized the entire transaction into a bytes.Buffer and then hashed the buffer. For large transactions (100+ KB), this allocated a buffer proportional to the tx size just to compute a hash.

Fix: Write transaction data directly to sha256.New() (which implements io.Writer) instead of an intermediate buffer. The double-SHA256 is computed as sha256(sha256(tx)) using a stack-allocated [32]byte for the intermediate hash.

Also adds a cachedHash *chainhash.Hash field to MsgTx that lazily caches the computed hash, invalidated by AddTxIn()/AddTxOut(). Applied the same streaming approach to MsgExtendedTx.TxHash().

Result: MsgTx.TxHash dropped from 3,758 MB to 0 MB in the allocation profile.

2. Block-level scratch buffer for deserialization (eliminates temporary script allocations)

During MsgTx.Bsvdecode, each script is read into a temporary buffer via scriptFreeList.Borrow(), then copied into a per-tx contiguous buffer. Scripts larger than 512 bytes bypass the pool and get a fresh make([]byte, size) allocation. For a 3.64 GB block, this produced ~3.7 GB of temporary allocations that were immediately discarded after copying.

Fix: Add bsvdecodeWithScratch() method that reads all scripts into a shared scratch buffer. The buffer is passed from MsgBlock.Bsvdecode and reused across all transactions:

• Reset to len=0 for each tx (capacity preserved)
• Grows only when a tx has more total script data than any previous tx
• After reading, scripts are copied into the exact-size per-tx contiguous buffer (unchanged)
• The scratch buffer's capacity stabilizes after the first few txs

Also pre-allocates MsgTx structs contiguously in MsgBlock.Bsvdecode (make([]MsgTx, txCount)) instead of individual stack-escape allocations per tx.

Single-tx Bsvdecode (non-block path) remains unchanged, using the existing script pool.

Result: Block deserialization allocations dropped from 7,514 MB to 3,790 MB (-49.6%). The remaining 3,716 MB is the irreducible per-tx contiguous script buffer (the actual script data that must live somewhere).

Test changes

• msg_block_test.go: Added clearBlockTxCaches helper to clear cachedHash before reflect.DeepEqual comparisons
• msg_tx_test.go: Clear cachedHash before reflect.DeepEqual comparisons
• msg_extended_tx_test.go: No test changes needed (MsgExtendedTx has no cached hash field)

Test plan

• All existing go-wire tests pass (go test -count=1 -short ./...)
• Verified against 3.64 GB testnet block in teranode HandleBlockDirect test
• TxHash correctness verified by existing TestTxTxHash and TestExtendedTxTxHash tests
• Block serialization/deserialization roundtrip verified by existing TestBlockSerialize* tests

[sonarqubecloud]

Quality Gate passed

Issues
5 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud