perf: streaming TxHash and block-level scratch buffer for deserialization (#106)

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

TxHash optimization:
- Write tx data directly to sha256.New() instead of serializing into
  an intermediate bytes.Buffer, eliminating a per-tx buffer allocation
  proportional to the transaction size.
- Cache computed hash in MsgTx.cachedHash field, invalidated by
  AddTxIn/AddTxOut. Applied to both MsgTx and MsgExtendedTx.

Block deserialization optimization:
- Add bsvdecodeWithScratch method that reads all scripts into a shared
  scratch buffer (reused across transactions) instead of allocating a
  fresh buffer per large script via scriptFreeList.Borrow.
- MsgBlock.Bsvdecode passes a shared scratch buffer to each tx,
  growing it only when a script larger than any previous one is
  encountered. After each tx, the buffer is reset (len=0) but
  capacity is preserved.
- Pre-allocate MsgTx structs contiguously in MsgBlock.Bsvdecode
  (one slice instead of per-tx heap allocations).

For a 3.64 GB testnet block (28,672 txs):
- Block deserialization: 7,514 MB → 3,790 MB (-49.6%)
- TxHash: 3,758 MB → 0 MB (eliminated from allocation profile)

* fix: resolve govet shadow lint warning in bsvdecodeWithScratch

Pre-declare scriptLen variable to avoid shadowing err from outer scope
in the output script reading loop.

Author: icellan

msg_block.go

@@ -83,17 +83,21 @@ func (msg *MsgBlock) Bsvdecode(r io.Reader, pver uint32, enc MessageEncoding) er
 		return messageError("MsgBlock.Bsvdecode", str)
 	}
 
-	msg.Transactions = make([]*MsgTx, 0, txCount)
+	// Pre-allocate all MsgTx structs contiguously and use a shared scratch
+	// buffer for reading script data across all transactions, avoiding a
+	// fresh heap allocation per large script.
+	txs := make([]MsgTx, txCount)
+	msg.Transactions = make([]*MsgTx, txCount)
+
+	var scratch []byte
 
 	for i := uint64(0); i < txCount; i++ {
-		tx := MsgTx{}
+		msg.Transactions[i] = &txs[i]
 
-		err := tx.Bsvdecode(r, pver, enc)
+		err := txs[i].bsvdecode(r, pver, enc, &scratch)
 		if err != nil {
 			return err
 		}
-
-		msg.Transactions = append(msg.Transactions, &tx)
 	}
 
 	return nil

msg_block_test.go

@@ -16,6 +16,14 @@ import (
 	"github.com/davecgh/go-spew/spew"
 )
 
+// clearBlockTxCaches clears cached hashes on all transactions in a block
+// so that reflect.DeepEqual comparisons are not affected by cache state.
+func clearBlockTxCaches(b *MsgBlock) {
+	for _, tx := range b.Transactions {
+		tx.cachedHash = nil
+	}
+}
+
 // TestBlock tests the MsgBlock API.
 func TestBlock(t *testing.T) {
 	pver := ProtocolVersion
@@ -57,6 +65,8 @@ func TestBlock(t *testing.T) {
 	tx := blockOne.Transactions[0].Copy()
 	_ = msg.AddTransaction(tx)
 
+	clearBlockTxCaches(msg)
+	clearBlockTxCaches(&blockOne)
 	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
 		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
 			spew.Sdump(msg.Transactions),
@@ -207,6 +217,8 @@ func TestBlockWire(t *testing.T) {
 			continue
 		}
 
+		clearBlockTxCaches(&msg)
+		clearBlockTxCaches(test.out)
 		if !reflect.DeepEqual(&msg, test.out) {
 			t.Errorf("Bsvdecode #%d\n got: %s want: %s", i,
 				spew.Sdump(&msg), spew.Sdump(test.out))
@@ -322,6 +334,8 @@ func TestBlockSerialize(t *testing.T) {
 			continue
 		}
 
+		clearBlockTxCaches(&block)
+		clearBlockTxCaches(test.out)
 		if !reflect.DeepEqual(&block, test.out) {
 			t.Errorf("Deserialize #%d\n got: %s want: %s", i,
 				spew.Sdump(&block), spew.Sdump(test.out))
@@ -340,6 +354,8 @@ func TestBlockSerialize(t *testing.T) {
 			continue
 		}
 
+		clearBlockTxCaches(&txLocBlock)
+		clearBlockTxCaches(test.out)
 		if !reflect.DeepEqual(&txLocBlock, test.out) {
 			t.Errorf("DeserializeTxLoc #%d\n got: %s want: %s", i,
 				spew.Sdump(&txLocBlock), spew.Sdump(test.out))

msg_extended_tx.go

@@ -6,6 +6,7 @@ package wire
 
 import (
 	"bytes"
+	"crypto/sha256"
 	"fmt"
 	"io"
 
@@ -70,14 +71,13 @@ func (msg *MsgExtendedTx) AddTxOut(to *TxOut) {
 
 // TxHash generates the Hash for the transaction.
 func (msg *MsgExtendedTx) TxHash() chainhash.Hash {
-	// Encode the transaction and calculate double sha256 on the result.
-	// Ignore the error returns since the only way the encode could fail
-	// is being out of memory or due to nil pointers, both of which would
-	// cause a run-time panic.
-	buf := bytes.NewBuffer(make([]byte, 0, msg.SerializeSize()))
-	_ = msg.Serialize(buf)
-
-	return chainhash.DoubleHashH(buf.Bytes())
+	// Serialize directly into a SHA-256 hasher to avoid allocating an
+	// intermediate buffer. Double SHA-256 is computed as sha256(sha256(tx)).
+	h := sha256.New()
+	_ = msg.Serialize(h)
+	var first [32]byte
+	h.Sum(first[:0])
+	return chainhash.Hash(sha256.Sum256(first[:]))
 }
 
 // Copy creates a deep copy of a transaction so that the original does not get