perf(runtime): skip per-clause state lookups in fork corrections via in-memory flags

[simonzg]

Why

Each EnforceTeslaForkN_Corrections function (forks 8–13) is called on every clause execution during block processing, not just once per block. Every call begins with a state trie read to check whether the correction has already been applied:

enforceFlag := builtin.Params.Native(rt.State()).Get(meter.KeyEnforceTesla_ForkN_Correction)

This state lookup runs on every single clause — forever — even though each correction fires exactly once in the node's entire lifetime. After the fork activation block, the correction is done and the flag is 1, but the trie read still happens on every clause of every subsequent block. With 6 fork correction functions (forks 8–13), that is 6 state trie reads wasted per clause execution across all future blocks on mainnet.

What Changed

Added six atomic uint32 package-level flags (fork8DoneFlag … fork13DoneFlag). Each correction function now starts with:

if atomic.LoadUint32(&forkNDoneFlag) == 1 {
    return
}

When the correction successfully writes its on-chain flag, it also atomically sets the in-memory flag. From that point forward, the function returns in ~1 ns (a single atomic load) instead of doing a state trie read.

The in-memory flag is set in the same code path as the on-chain flag, so they are always consistent. On node restart, the in-memory flag starts at 0 — but the very first clause execution after the fork will re-check the state, find the flag already set, and set the in-memory flag, so only one state lookup happens on restart.

Expected Impact

• Eliminates 6 state trie reads per clause execution on all blocks after fork13 activation.
• At typical mainnet load (hundreds of clauses per block, blocks every 2 seconds), this removes millions of wasted state reads per day.
• Particularly impactful for blocks with many transactions/clauses (DeFi activity), where the per-clause overhead is paid many times per block.