execution: restore commitment deferred updates hook mechanism

[Giulio2002]

• Add DeferredHooker interface for deferring branch updates to flush hooks
• Add FlushHooks/AddFlushHook to SharedDomains for deferred execution
• Enable deferred hooker in fork validation mode at chain tip
• Call FlushHooks in MergeExtendingFork to apply deferred updates
• Capture commitment writes during FlushHooks and add to past changesets

Impact:

• -33% time for commitment
• -10% overall time for block exec on tip

[Copilot]

Pull request overview

Restores a mechanism to defer commitment (branch) updates during fork validation and flush them later (e.g., at MergeExtendingFork), aiming to reduce commitment and tip execution time.

Changes:

• Add support for deferring commitment branch updates and storing them as a pending update to be flushed later.
• Flush deferred updates during fork-choice merge flows and capture commitment writes into past changesets.
• Add plumbing to reset/transfer pending updates across contexts and merges.

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
execution/stagedsync/exec3.go	Enables deferred commitment updates at chain tip during fork validation and ensures reset afterward.
execution/execmodule/forkchoice.go	Resets pending deferred updates on forkchoice handling; updates MergeExtendingFork call signature.
execution/execmodule/ethereum_execution.go	Resets pending deferred updates before chain validation.
execution/engineapi/engine_helpers/fork_validator.go	Flushes pending deferred updates during fork merge (current implementation flushes on the fork domains).
execution/commitment/hex_patricia_hashed.go	Allows leaving deferred updates for the caller and adds APIs to take/apply/inspect deferred updates.
execution/commitment/commitmentdb/commitment_context.go	Adds pending-update storage/flush and deferral logic around Process().
execution/commitment/commitment.go	Introduces PendingCommitmentUpdate and splits deferred update application into a reusable function.
db/state/temporal_mem_batch.go	Adds lookup of changesets by block number to support deferred-write attribution.
db/state/stateifs/domain_putter.go	Adds shared interfaces/types for commitment-domain writes.
db/state/execctx/domain_shared.go	Transfers pending updates on merge; adds Reset/Flush APIs and changeset switching during flush.

Comments suppressed due to low confidence (1)

execution/engineapi/engine_helpers/fork_validator.go:155

• Flushing pending updates on fv.sharedDom before sd.Merge(fv.sharedDom) defeats the pending-update transfer done during SharedDomains.Merge and can attribute deferred writes to the fork domain’s in-memory changesets rather than the canonical sd changesets. A safer approach is to merge first (which transfers the pending update onto sd), then call sd.FlushPendingUpdates(ctx, tx) so the deferred writes are applied against the canonical domains/changeset accumulator.

func (fv *ForkValidator) MergeExtendingFork(ctx context.Context, tx kv.TemporalTx, sd *execctx.SharedDomains, accumulator *shards.Accumulator, recentReceipts *shards.RecentReceipts) error {
	fv.lock.Lock()
	defer fv.lock.Unlock()
	start := time.Now()
	if fv.sharedDom != nil {
		if err := fv.sharedDom.FlushPendingUpdates(ctx, tx); err != nil {
			return err
		}
		err := sd.Merge(fv.sharedDom)
		if err != nil {
			return err
		}

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

most tests cover it already. see Kurtosis and Hive