execution/commitment: route trie trace through an io.Writer

Replace HexPatriciaHashed's `trace bool` + `fmt.Printf` pattern with a single
`traceW io.Writer`. `SetTrace(bool)` becomes `SetTraceWriter(io.Writer)` on the
Trie interface; nil disables tracing. The `if traceW != nil` guard is kept, so
disabled tracing stays free.

Capture is unified onto the same writer: SetCapture/GetCapture ([]string) are
removed; ComputeCommitment points traceW at a bytes.Buffer when capture is
requested and DrainCapture() returns its contents. This makes trace output
configurable (stdout, file, or a bytes.Buffer for assertions in tests).

The concurrent trie wraps the writer in a mutex-guarded syncWriter and fans it
out to the root and all mounts so cross-goroutine trace writes are safe.
GenerateWitness resets traceW to nil to preserve the prior trace-off behavior.

traceDomain remains a separate bool gating a stdout dump.

Author: awskii

db/state/execctx/domain_shared.go

@@ -618,10 +618,9 @@ func (sd *SharedDomains) InlineTouchKeyDisabled() bool {
 	return sd.disableInlineTouchKey
 }
 
-func (sd *SharedDomains) SetTrace(b, capture bool) []string {
+func (sd *SharedDomains) SetTrace(b, capture bool) {
 	sd.trace = b
 	sd.commitmentCapture = capture
-	return sd.sdCtx.GetCapture(true)
 }
 
 func (sd *SharedDomains) HasPrefix(domain kv.Domain, prefix []byte, roTx kv.Tx) ([]byte, []byte, bool, error) {

execution/commitment/commitment.go

@@ -22,6 +22,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"io"
 	"math/bits"
 	"slices"
 	"strconv"
@@ -93,12 +94,10 @@ type Trie interface {
 	// RootHash produces root hash of the trie
 	RootHash() (hash []byte, err error)
 
-	// Makes trie more verbose
-	SetTrace(bool)
-	// Trace domain writes only (no filding etc)
+	// SetTraceWriter sets the trace writer; nil disables tracing
+	SetTraceWriter(io.Writer)
+	// Trace domain writes only (no folding etc)
 	SetTraceDomain(bool)
-	SetCapture(capture []string)
-	GetCapture(truncate bool) []string
 	EnableCsvMetrics(filePathPrefix string)
 
 	// Variant returns commitment trie variant

execution/commitment/commitment_bench_test.go

@@ -31,7 +31,7 @@ func BenchmarkHexPatriciaHashedFold(b *testing.B) {
 	ctx := context.Background()
 	ms := NewMockState(b)
 	hph := NewHexPatriciaHashed(1, ms, DefaultTrieConfig())
-	hph.SetTrace(false)
+	hph.SetTraceWriter(nil)
 
 	// Build a trie with accounts and storage to exercise all fold paths
 	plainKeys, updates := NewUpdateBuilder().

execution/commitment/commitmentdb/commitment_context.go

@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"os"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -49,6 +50,7 @@ type SharedDomainsCommitmentContext struct {
 	patriciaTrie  commitment.Trie
 	justRestored  atomic.Bool // set to true when commitment trie was just restored from snapshot
 	trace         bool
+	captureBuf    *bytes.Buffer // buffer for CommitmentCapture trace output
 	stateReader   StateReader
 	paraTrieDB    kv.TemporalRoDB // DB used for para trie and/or parallel trie warmup
 	// warmupBase holds the construction-time portion of the per-call WarmupConfig.
@@ -150,12 +152,16 @@ func (sdc *SharedDomainsCommitmentContext) SetCustomHistoryStateReader(stateRead
 
 func (sdc *SharedDomainsCommitmentContext) SetTrace(trace bool) {
 	sdc.trace = trace
-	sdc.patriciaTrie.SetTrace(trace)
 }
 
-// SetCapture enables/disables trie operation capture for diagnosis.
-func (sdc *SharedDomainsCommitmentContext) SetCapture(capture []string) {
-	sdc.patriciaTrie.SetCapture(capture)
+// DrainCapture returns the accumulated capture buffer content and resets the buffer.
+func (sdc *SharedDomainsCommitmentContext) DrainCapture() string {
+	if sdc.captureBuf == nil || sdc.captureBuf.Len() == 0 {
+		return ""
+	}
+	s := sdc.captureBuf.String()
+	sdc.captureBuf.Reset()
+	return s
 }
 
 // GetUpdates returns the current updates buffer. Used by the commitment
@@ -215,10 +221,6 @@ func (sdc *SharedDomainsCommitmentContext) Reset() {
 	}
 }
 
-func (sdc *SharedDomainsCommitmentContext) GetCapture(truncate bool) []string {
-	return sdc.patriciaTrie.GetCapture(truncate)
-}
-
 func (sdc *SharedDomainsCommitmentContext) ClearRam() {
 	sdc.updates.Reset()
 	sdc.Reset()
@@ -319,21 +321,28 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context
 		}
 		log.Debug("[commitment] processed", "block", blockNum, "txNum", txNum, "keys", common.PrettyCounter(updateCount), "keys/s", common.PrettyCounter(keysPerSec), "mode", sdc.updates.Mode(), "spent", took, "rootHash", hex.EncodeToString(rootHash))
 	}()
+	// Configure trace writer before any trie operations (including the early-return
+	// RootHash below) so a stale traceW from a prior call doesn't leak into captureBuf.
+	sdc.patriciaTrie.SetTraceDomain(sdc.sharedDomains.Trace())
+	if sdc.sharedDomains.CommitmentCapture() {
+		if sdc.captureBuf == nil {
+			sdc.captureBuf = new(bytes.Buffer)
+		}
+		sdc.captureBuf.Reset() // ensure clean slate for this computation
+		sdc.patriciaTrie.SetTraceWriter(sdc.captureBuf)
+	} else if sdc.trace {
+		sdc.patriciaTrie.SetTraceWriter(os.Stderr)
+	} else {
+		sdc.patriciaTrie.SetTraceWriter(nil)
+	}
+
 	if updateCount == 0 {
 		rootHash, err = sdc.patriciaTrie.RootHash()
 		return rootHash, err
 	}
 
 	// data accessing functions should be set when domain is opened/shared context updated
 
-	sdc.patriciaTrie.SetTrace(sdc.trace)
-	sdc.patriciaTrie.SetTraceDomain(sdc.sharedDomains.Trace())
-	if sdc.sharedDomains.CommitmentCapture() {
-		if sdc.patriciaTrie.GetCapture(false) == nil {
-			sdc.patriciaTrie.SetCapture([]string{})
-		}
-	}
-
 	trieContext := sdc.trieContext(tx, blockNum, txNum)
 
 	// If trie trace is configured, wrap the context with a recorder.

execution/commitment/hex_concurrent_patricia_hashed.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"sync"
 	"time"
 
@@ -118,8 +119,8 @@ func (p *ConcurrentPatriciaHashed) foldNibble(ctx context.Context, nib int) erro
 }
 
 func (p *ConcurrentPatriciaHashed) unfoldRoot(ctx context.Context, ctxFactory TrieContextFactory) error {
-	if p.root.trace {
-		fmt.Printf("=============ROOT unfold============\n")
+	if p.root.traceW != nil {
+		fmt.Fprintf(p.root.traceW, "=============ROOT unfold============\n")
 	}
 	// if p.root.rootPresent && p.root.root.hashedExtLen == 0 { // if root has no extension, we have to unfold
 	zero := []byte{0}
@@ -133,8 +134,8 @@ func (p *ConcurrentPatriciaHashed) unfoldRoot(ctx context.Context, ctxFactory Tr
 	}
 	// }
 
-	if p.root.trace {
-		fmt.Printf("=========END=ROOT unfold============\n")
+	if p.root.traceW != nil {
+		fmt.Fprintf(p.root.traceW, "=========END=ROOT unfold============\n")
 	}
 
 	for i := range p.mounts {
@@ -159,36 +160,41 @@ func (p *ConcurrentPatriciaHashed) Close() {
 	}
 }
 
-func (p *ConcurrentPatriciaHashed) SetTrace(b bool) {
-	p.root.SetTrace(b)
-	for i := range p.mounts {
-		p.mounts[i].SetTrace(b)
-	}
+// syncWriter wraps an io.Writer with a mutex for goroutine-safe writes.
+// Used by ConcurrentPatriciaHashed to protect concurrent fmt.Fprintf calls
+// from root and mount goroutines writing to the same underlying writer.
+type syncWriter struct {
+	mu sync.Mutex
+	w  io.Writer
 }
-func (p *ConcurrentPatriciaHashed) SetTraceDomain(b bool) {
-	p.root.SetTraceDomain(b)
-	for i := range p.mounts {
-		p.mounts[i].SetTraceDomain(b)
-	}
+
+func (sw *syncWriter) Write(p []byte) (n int, err error) {
+	sw.mu.Lock()
+	n, err = sw.w.Write(p)
+	sw.mu.Unlock()
+	return
 }
 
-func (p *ConcurrentPatriciaHashed) GetCapture(truncate bool) []string {
-	capture := p.root.GetCapture(truncate)
-	if truncate {
+func (p *ConcurrentPatriciaHashed) SetTraceWriter(w io.Writer) {
+	if w != nil {
+		sw := &syncWriter{w: w}
+		p.root.SetTraceWriter(sw)
 		for i := range p.mounts {
-			p.mounts[i].SetCapture(nil)
+			p.mounts[i].SetTraceWriter(sw)
+		}
+	} else {
+		p.root.SetTraceWriter(nil)
+		for i := range p.mounts {
+			p.mounts[i].SetTraceWriter(nil)
 		}
 	}
-	return capture
 }
-
-func (p *ConcurrentPatriciaHashed) SetCapture(capture []string) {
-	p.root.SetCapture(capture)
+func (p *ConcurrentPatriciaHashed) SetTraceDomain(b bool) {
+	p.root.SetTraceDomain(b)
 	for i := range p.mounts {
-		p.mounts[i].SetCapture(capture)
+		p.mounts[i].SetTraceDomain(b)
 	}
 }
-
 func (p *ConcurrentPatriciaHashed) EnableCsvMetrics(filePathPrefix string) {
 	p.root.EnableCsvMetrics(filePathPrefix)
 	for i := range p.mounts {
@@ -199,10 +205,18 @@ func (p *ConcurrentPatriciaHashed) EnableCsvMetrics(filePathPrefix string) {
 }
 
 // pass -1 to enable trace just for root trie
-func (p *ConcurrentPatriciaHashed) SetParticularTrace(b bool, n int) {
-	p.root.SetTrace(b)
-	if n < len(p.mounts) && n >= 0 {
-		p.mounts[n].SetTrace(b)
+func (p *ConcurrentPatriciaHashed) SetParticularTrace(w io.Writer, n int) {
+	if w != nil {
+		sw := &syncWriter{w: w}
+		p.root.SetTraceWriter(sw)
+		if n < len(p.mounts) && n >= 0 {
+			p.mounts[n].SetTraceWriter(sw)
+		}
+	} else {
+		p.root.SetTraceWriter(nil)
+		if n < len(p.mounts) && n >= 0 {
+			p.mounts[n].SetTraceWriter(nil)
+		}
 	}
 }
 
@@ -245,8 +259,8 @@ func (t *Updates) ParallelHashSort(ctx context.Context, pph *ConcurrentPatriciaH
 			cnt := 0
 			err := nib.Load(nil, "", func(hashedKey, plainKey []byte, table etl.CurrentTableReader, next etl.LoadNextFunc) error {
 				cnt++
-				if phnib.trace {
-					fmt.Printf("\n%x) %d plainKey [%x] hashedKey [%x] currentKey [%x]\n", ni, cnt, plainKey, hashedKey, phnib.currentKey[:phnib.currentKeyLen])
+				if phnib.traceW != nil {
+					fmt.Fprintf(phnib.traceW, "\n%x) %d plainKey [%x] hashedKey [%x] currentKey [%x]\n", ni, cnt, plainKey, hashedKey, phnib.currentKey[:phnib.currentKeyLen])
 				}
 				if err := phnib.followAndUpdate(hashedKey, plainKey, nil); err != nil {
 					return fmt.Errorf("followAndUpdate[%x]: %w", ni, err)
@@ -259,8 +273,8 @@ func (t *Updates) ParallelHashSort(ctx context.Context, pph *ConcurrentPatriciaH
 			if cnt == 0 {
 				return nil
 			}
-			if pph.mounts[ni].trace {
-				fmt.Printf("ConcurrentTrie: folding [%2x] keys %d maxDepth %d\n", ni, cnt, phnib.depths[0])
+			if pph.mounts[ni].traceW != nil {
+				fmt.Fprintf(pph.mounts[ni].traceW, "ConcurrentTrie: folding [%2x] keys %d maxDepth %d\n", ni, cnt, phnib.depths[0])
 			}
 			return pph.foldNibble(gctx, ni)
 		})
@@ -269,8 +283,8 @@ func (t *Updates) ParallelHashSort(ctx context.Context, pph *ConcurrentPatriciaH
 		return nil, err
 	}
 
-	if pph.root.trace {
-		fmt.Printf("======= folding ROOT trie =========\n")
+	if pph.root.traceW != nil {
+		fmt.Fprintf(pph.root.traceW, "======= folding ROOT trie =========\n")
 	}
 	// TODO zero active rows could be a clue to some invalid cases
 	if pph.root.activeRows == 0 {
@@ -289,8 +303,8 @@ func (t *Updates) ParallelHashSort(ctx context.Context, pph *ConcurrentPatriciaH
 	if err != nil {
 		return nil, err
 	}
-	if pph.root.trace {
-		fmt.Printf("======= folding root done =========\n")
+	if pph.root.traceW != nil {
+		fmt.Fprintf(pph.root.traceW, "======= folding root done =========\n")
 	}
 	// have to reset trie since we do not do any unfolding
 	return rootHash, nil