Hostile-read repairs across the kernel artifacts: 17 confirmed over-claims fixed to honest

A 6-lens hostile panel with adversarial verification confirmed 17 attacks that
would hold in a public takedown. All repaired: the MI contract now carries the
two base-fee floor-lapse windows (12,978,617-13,087,959 and
13,596,033-13,596,141) as explicit ruleset validation exceptions, so a stranger
implementing the written rules no longer halts where our own follower did; the
honesty boundary now states the full record of reject-on-disagreement including
the windows, and why the fact stays load-bearing; the independence claim is
bounded (upstream skeletons yes, AERE ruleset has one author in both forks, so
a common-author bug passes any differential gate by construction); the harness
verdict claims only what it measures, records engine identity via
web3_clientVersion on every run, refuses same-URL endpoint pairs, and prints
its NOT MEASURED block on every run; stage 4 names the live engine (upstream
parallel processing enabled by default, idling on empty blocks) and its
oracle's model limits; 'governed registry' became 'owner-controlled' with the
single-key fact stated. The panel also confirmed the import-proof doc claimed
a two-month validation history where six days is the truth; fixed.
This commit is contained in:
Aere Network committed 2026-08-15 23:28:24 +03:00
1 parent 46c42164de
commit f2ab368c36
5 files changed
+116 -19

No files matched your search

+45 -7
View File
@@ -150,10 +150,19 @@ input or output. Only the commitments above are.
**Determinism is measured across implementations, not asserted from one.** A single client
agreeing with itself proves nothing about determinism. The measurement that means something is
two independent engines, built by different teams in different languages, deriving the same
commitments from the same input. Today that is Besu (serial, live producer) versus Nethermind
(independent second client, live at `client2.aere.network`). Tomorrow it is Block-STM through
the same seam (treapta 4), measured by the same harness.
two engines built by different teams in different languages deriving the same commitments from
the same input. Today that is Besu (live producer; note that upstream Besu ships with parallel
transaction processing enabled by default and the fleet does not disable it, so the live engine
is the parallel-capable one, idling on empty blocks) versus Nethermind (second client, live at
`client2.aere.network`). **The independence claim has a boundary, stated here rather than found
by a hostile reader:** it holds for the upstream engine skeletons (different teams, different
languages, different codebases), and it does NOT hold for the AERE-specific ruleset. The floor
fork, the lapse windows and the PQ precompiles have a single author, this project, ported into
both forks. A rule bug with a common author passes any differential gate by construction,
because both sides inherit it. Cross-client agreement therefore catches implementation
divergence, not specification error; specification error is what the formal models and hostile
reads are for. Tomorrow Block-STM enters through the same seam (treapta 4), measured by the
same harness.
**Honesty boundary, carried from `cross-client-determinism/`.** A matching header root served
over RPC proves, on its own, only that both endpoints **serve the same bytes** for a block that
@@ -164,6 +173,19 @@ that sits in the follower's canonical chain below its processed head is therefor
`post_state` the follower's own engine reproduced. The harness states this boundary on every run
and never claims more than it.
The full record of that mechanism, stated before a hostile reader states it for us: every time
reject-on-disagreement fired on the live chain, the resolution was to change the rejecting
follower until it accepted the producer's chain. The two rejections cited above were resolved by
patching the follower (missing predeploys, missing chainspec keys), and the largest episode is
the floor-lapse window of section 6: the follower refused ~109,000 canonical blocks and was
given a hardcoded acceptance window (`AereFloorLapse.cs`). Two things keep the fact
load-bearing anyway. First, the acceptance windows live in header-fee derivation only; state
root, receipts root and gas used stay fully validated inside the windows, so the post-state
inference above survives. Second, the mechanism demonstrably still fires: after the first
window was encoded, the follower stopped again at 13,596,032, which is exactly how the second
lapse window was discovered. A rejection mechanism whose firings keep finding real producer
defects is doing its job; a contract that cited only its flattering firings was not.
---
## 6. Admissible inputs
@@ -186,8 +208,22 @@ and never claims more than it.
the live AERE fork. It is a **rule keyed on block number**, not an ambient input: every node
computes the same base-fee floor for the same height. An engine that lacks it computes a
different fee, therefore a different state root, and is a different MI, not the same one with
a different environment. This is exactly the D-150 lesson: a binary missing the floor fork
froze a real node at a state-root mismatch while every shape check stayed green.
a different environment. A binary missing the floor fork froze a real node at a state-root
mismatch while every shape check stayed green.
- **The two floor-lapse windows, and they are part of the ruleset, not a footnote.** The live
chain contains two dated windows in which the floor was NOT applied by the block producer:
blocks **12,978,617 to 13,087,959** (109,343 blocks; the floor property had been silently
lost from every validator's options and the base fee decayed to single-digit wei), and
blocks **13,596,033 to 13,596,141** (a second, smaller lapse, found when the follower
stopped again exactly at its edge). Inside these windows the base fee of a block is **not a
function of the parent header**; it depends on which validator won the round. The rule an
implementation must carry is therefore: **within these two windows, `baseFeePerGas` is
accepted as given in the header** (validation exception), and outside them the floor rule
applies strictly. An implementer who takes the floor rule without the windows will halt at
block 12,978,617, which is precisely what this project's own second client did until the
exception was encoded (`AereFloorLapse.cs` in the published follower source). A contract
that omits the windows sends every stranger into the same wall, so they are stated here, in
the ruleset, with their exact bounds.
Everything not in this list is inadmissible as an input. In particular: no OS clock, no RNG, no
environment read at execution time, no network, no cross-block mutable cache.
@@ -276,7 +312,9 @@ fork build.
## 10. What this contract does NOT claim
Printed as NOT MEASURED by the harness, never as a pass:
The harness prints a NOT MEASURED block naming these on every run, and its JSON report carries
them in the `honesty` field, so the non-claims travel with every result rather than living only
in this document:
- **That consensus is post-quantum.** It is not. Consensus finality is classical secp256k1 ECDSA
QBFT plus a Falcon certificate. MI is an execution seam and says nothing about consensus.