Skip to content

release: integrate Mantle reth v1.7.0 into main - #236

Open
ivanwang-coder wants to merge 435 commits into
mainfrom
dev/mantle-v1.7.0
Open

ivanwang-coder wants to merge 435 commits into
mainfrom
dev/mantle-v1.7.0

Conversation

@ivanwang-coder

Copy link
Copy Markdown

Promote the Mantle reth v1.7.0 development line to main. The branch includes flashblocks/preconfirmation and WS proxy work, execution dependency alignment, historical RPC forwarding, proofs-history/RPC wiring, gas estimation and txpool fixes, and the debug-tracer updates.

Recent integrations include #198 and #235. The latter pins the access-list gas accounting fix from Mantle-v2 #415.

Branch snapshot:

  • Head: dev/mantle-v1.7.0@b3953e4ebc2858b8f263a01b6e571c4a82ab7e4b.
  • Base: main@574e7f39f79fbc64ca0881ff8f9229a02ff7a051.
  • Comparison: 260 commits ahead, 0 behind.

Validation already executed for this source tree: full just pr passed; the U10 actual-RPC regression fails on the old dependency and passes all four request forms with the fixed dependency. Mantle integration tests reported 321 passed, 3 skipped and 1 flaky; the flaky test passed both its configured retry and a separate run with retries disabled. Codex and Claude independently reviewed the #235 change and returned ALLOW. Those narrow reviews do not constitute an independent review of this entire 260-commit integration.

This PR creates the development-to-main integration for review. Production-aligned acceptance and deployment approval remain separate. Existing dev/mantle-v1.6.3 integration PR #122 is left unchanged.

adam-xu-mantle and others added 30 commits October 15, 2026 13:44
Two unrelated things the canonical handler got wrong, both in this file.

**The gap.** `canonical_state_stream`'s `Item` is the notification itself,
so `RecvError::Lagged` is folded away inside it and this handler could not
see — let alone report — that the broadcast had dropped notifications on
it. Subscribe to the channel directly and keep the gap as its own answer:
it is neither a failure nor an end, and the next read still returns the
notification after the ones that were dropped.

Dropping them is not free here. `observe_persisted` and `sweep` reconcile
from full state and heal on the next notification, but `mark_committed`
and `observe_reorg` are edge-triggered with no catch-up pass, so a gap can
leave a promised commitment without a record for a later reorg to put
back. Hence `warn!` rather than `debug!`, and
`mantle.canon.notifications_lagged_total`.

Overflowing the 256-slot channel takes roughly 8.5 minutes of not draining
at 2s blocks: backfill emits nothing on it, a reorg of any depth is one
slot, and a head advance of K blocks is one notification. So this is a
stall symptom rather than a throughput one, and
`mantle.canon.notification_duration` is here to tell a stalled handler
from a quiet chain. It spans the whole loop body, `fifo.snapshot().await`
included — that call takes the lock the admission path holds, and lock
contention is the only plausible way this handler falls behind.

**The drift signal.** The build loop records every executed pool
transaction in `Commitments`, so `mark_committed` stamped them and
`uncommit` reported them as reorg drift: thousands of warnings per reorg
on a counter that exists to report broken preconfirmations, with the real
signal buried among them. `ClaimKind` already draws the line the sibling
counter `preconf.tx.commitment_broken_total` respects, so `uncommit`
returns it and the handler counts only `Promised`. Both kinds are still
put back — re-injection is what the slice path's pool pruning relies on.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
… gap

Two subscribers drove the canonical-state channel with `while let
Some(Ok(..))`, which reads `RecvError::Lagged` as the end of the stream:

- the overlay's canonical feed ended its task on the first gap,
  permanently and silently, so the overlay stopped tracking canonical
  state for the rest of the process;
- `wait_for_canonical_receipt` returned `None`, which settles
  `eth_sendRawTransactionSync`'s three-way select immediately and answers
  the caller with a confirmation timeout it never waited out — while the
  flashblocks branch may have been about to find the receipt.

The second one is the odd one: eight lines above it, the same file already
handles a lagging flashblocks receipt queue by warning and carrying on.

`canonical::{forward_canonical_state, await_canonical_match}` now hold
both loops. Dropping what was skipped is safe for this consumer: every
canonical block is reconciled against the overlay as it arrives rather
than applied as a delta, and the cache watermark is assigned rather than
advanced, so the next notification reaches the right conclusion whatever
came before it. Losing the subscription is what is not safe, and nothing
reported it — a dead feed is indistinguishable from a quiet chain in every
metric this crate exports. `flashblocks.queue_depth` actually points the
wrong way, since it is set on dequeue.

Gaps count under `mantle.canon.notifications_lagged_total` and each
notification's handling is timed into `mantle.canon.notification_duration`,
both labelled by subscriber so one panel covers every caller of these two
helpers.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Both of these started as bug reports and ended as characterization tests,
which is the more useful outcome: each pins a contract that nothing was
holding, and each would have turned red if the reading behind the report
had been right.

`an_upstream_that_ends_the_stream_is_reconnected_on_the_backoff`: the
proxy's `run` reconnects without consulting the backoff when
`connect_and_listen` returns `Ok(())`, which looks like an unthrottled
reconnect loop on an upstream that drops the TCP stream without a close
frame. It is not reachable: tungstenite reports an abrupt end as an error,
so the `Err` arm and its backoff are what actually runs. The test holds
that arm in place — and carries a non-vacuity assertion, because a
reconnect test that only bounds the rate passes just as well when nothing
reconnects at all.

`a_queued_commitment_that_loses_its_nonce_is_answered_with_an_error`:
the pool arm's two gates are both inert for a commitment that is queued
but not yet applied, so an ordinary transaction can take its nonce. That
is within the contract — `tx_hash` binds from the moment the event goes
out, and the apply that produces the event is also what claims the slot,
so there is no window where a promise stands unprotected. What the
contract does require is that nothing binding goes out for a transaction
that then does not land, and that boundary had no test. It does now,
alongside the promised-commitment case it sits next to.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…t-blocks

fix: three silent failures in the canonical/flashblocks consumers
…ream

Reverts the Mantle-only change from 18cab32 (feat(cli): enable debug_verbosity/vmodule
by gating log reload on debug namespace), together with the comment rewording in the
previous commit. That change installed the reloadable log filter layer when the debug
RPC namespace was enabled, so debug_verbosity / debug_vmodule could change log levels at
runtime. reth at aef8d3e no longer has those two methods, so nothing uses the layer.

op-reth/crates/cli/src/{app.rs,commands/mod.rs,lib.rs} are now identical to upstream
op-reth v2.4.2.
ci(release): pass the tag and commit into the cross build
revert(cli): drop the debug-namespace log reload gating, back to upstream
… sends

The 5 MiB ceiling guarded `Message::Binary` only. Mantle's publisher writes
`Utf8Bytes`, so every slice on the production path arrived as
`Message::Text` and was forwarded unchecked. The constant was named
`MAX_BINARY_SLICE_BYTES` and its doc said "from a binary frame", which is
why the gap survived reading: nothing about it invited the question of
what the other arm does.

Three changes, one defect:

- text frames are checked on arrival, and an oversized one is dropped with
  a warning rather than closing the connection — the same treatment the
  binary arm already gives a frame it cannot decode;
- the constant is `MAX_SLICE_BYTES` now, because it governs both arms;
- the upstream connection sets `max_message_size`, which is where a
  hostile upstream is actually stopped. Neither `connect_async` call set a
  `WebSocketConfig`, so the real ceiling was tungstenite's 64 MiB default
  and the checks ran on a frame already buffered whole. The constant's own
  doc promised that "a hostile or misconfigured upstream cannot force a
  large allocation"; until now it did not.

Setting the protocol limit to exactly `MAX_SLICE_BYTES` — refusing to
buffer what we would refuse to read — changes behaviour for an upstream
that persistently sends oversized frames: it now disconnects and backs off
instead of dropping frame after frame. That upstream was already useless
to us, since every one of its slices would have been dropped; failing
loudly beats serving nothing quietly.

`the_ceiling_matches_the_consumer_s` was not wrong, but it held the
proxy's ceiling against the consumer's on an arm production never used.
The new test covers the arm it does use, and asserts a well-sized frame is
still forwarded — a "nothing arrived" assertion passes just as well when
nothing could have arrived.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…back

Three things, in one commit because `metrics_seed`'s drift check couples
them: it fails if a metric is emitted but unseeded *or* seeded but
unemitted, so a new metric, a change to what the check can see, and a
rename of the namespace it scans cannot land apart without a red commit
between them.

**1. The dropped push result.** `observe_reorg` threw away what
`push_if_absent` returned. `ConflictActive` there means a reverted
commitment's `(sender, nonce)` is held by a different live entry, and the
commitment cannot go back — a transaction whose receipt already reached a
client, dropped with no log and no counter.

It should be unreachable: `uncommit` keeps the slot, so admission refuses
anything else on that nonce while the record stands. Reaching it means the
record went early — a reorg deeper than `SEAL_DEPTH`, or a `mark_committed`
that never ran because its notification was dropped. Reported rather than
resolved: both transactions may have had a receipt go out, so no choice
left keeps every promise. `preconf.canon.reinject_conflict_total`.

**2. The drift check could not see a labelled metric.** It matched
`counter!("prefix` with the name adjacent to the paren, and rustfmt moves
the name to its own line as soon as labels push the call past the line
width. Every labelled emit was therefore exempt from the rule the check
exists to enforce — including the two `mantle.canon.*` series added for
the canonical-gap work, which have been emitting into an unregistered
series since. That is the exact failure seeding exists to prevent: a
counter that should sit at zero instead does not exist, and "no lag ever"
reads the same as "no such metric".

**3. The namespace is `flashblocks.` on both sides now.** The producer
metrics here used `flashblock.`, the consumer crate uses `flashblocks.`,
and nothing but habit decided which. Plural matches the spec name, the
crate name and the CLI flags (`--flashblocks.enable`), so the 15 producer
series move. Mechanical: `"flashblock.` → `"flashblocks.`, no behaviour
change, and nothing depends on the old names yet — the feature is not
released.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…hive

The producer keeps `ring_capacity` slices for a reconnecting subscriber —
roughly six seconds at the default capacity and slice interval, after
which a resume comes back gapped and the consumer loses the rest of that
block. The consumer's keepalive was 30s, so a dead connection took up to
two ticks, 60s, to notice: nine times the budget it has to fit inside.
Every detection that depended on it was guaranteed to resume into a gap.

2s bounds detection at 4s and leaves the handshake and the replay room.
The interval is cheap — one frame on one connection — and a reconnect that
turns out unnecessary resumes from the archive at no cost, so being early
costs less here than being late.

Both halves of the budget now say so: `DEFAULT_RING_CAPACITY` names the
keepalive, and the keepalive explains where its number comes from. Shrink
one and the other has to follow.

Only a connection that goes quiet *without* ending needs the keepalive at
all. A stream that ends is reported by the socket, and the subscriber
reconnects on it immediately — `an_upstream_that_ends_the_stream_is_
noticed_without_waiting_for_a_ping` holds that in place with the keepalive
effectively off, because the read branch is written `Some(msg) =
read.next()` and would wait out two pings if the stream ever yielded
`None` instead of an error. It does not, today: tungstenite surfaces an
abrupt end as `Err`. The test exists so that stays true.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`CanonStateNotification::block_receipts` returns both sides of a reorg —
the reverted receipts and the committed ones — distinguished only by a
`bool` alongside each. `wait_for_canonical_receipt` discarded it, so a
transaction found in a block the reorg had just taken back counted as
confirmed.

What follows is not a wrong receipt but a wrong answer: the match ends the
wait, the authoritative `eth_getTransactionReceipt` that comes next finds
nothing, and `send_raw_transaction_sync`'s select settles on that `None`.
The caller is told its transaction timed out — before the timeout it asked
for, and while the next block may be about to include it. The same shape
as the broadcast-gap bug this method had: one early `None` decides a race
it should have stayed out of.

The predicate moves into `names_a_canonical_receipt`, which is a free
function so the flag can be tested without standing up an eth API.

Also writes down why the overlay's canonical feed reads `committed()` and
never `reverted()`, which until now was a call site with no stated reason:
on a reorg `committed()` *is* the new chain, and the overlay reconciles
against each block as it arrives rather than rolling back, so the blocks
that replace a reverted one carry everything it acts on. The cost — a
reorg is inferred from a transaction list that stopped matching, so one
reaching only untracked heights goes unnoticed — is written down with it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Places where op-reth differed from upstream op-reth v2.4.2 without changing behaviour:

- rpc/src/eth/transaction.rs: drop the fill_transaction override. It copied the reth
  default with maxFeePerGas = 2 * base_fee + tip; paradigmxyz#25258 made that the
  default and is in the pinned reth aef8d3e, as the override's own comment anticipated.
  reth-rpc-convert is no longer used by the crate and is dropped from its manifest.
- evm/src/l1.rs, evm/src/lib.rs: call revm_spec_by_timestamp_after_bedrock again. It is
  upstream's re-export of alloy_op_evm::spec_by_timestamp_after_bedrock, the function the
  full path named. The EIP-7825 exemption in evm_env_for_payload stays.
- chainspec/Cargo.toml: drop the duplicated alloy-op-hardforks/serde feature entry.
- rpc/src/engine.rs: drop the Mantle-only line in the get_payload_v5 docs.

rpc/src/eth/transaction.rs and rpc/src/engine.rs are now identical to upstream.
…-divergences

chore(op-reth): drop divergences from upstream v2.4.2 that do nothing
`observe_reorg` had no test and no way to get one: it was a method on a
handler that cannot be built without a provider, and its three decisions
were visible only as log lines and counter increments that nothing in the
suite asserts. Both gates added recently — count drift only for a promise,
report a nonce held by another live entry — could have been deleted whole
and left every test green.

The pass becomes `reinject_reverted(fifo, old)`, free because it needs the
queue and nothing else, and it returns what it found instead of counting
in place. The caller owns the metrics, so the series and the tests now
read the same numbers rather than two parallel accounts of them.

Four cases, one per decision the pass makes:

- a promised commitment is drift and goes back, keeping its slot — the
  case the mechanism exists for;
- an executed pool transaction goes back *without* counting as drift. The
  build loop records every pool transaction it executes, so most of what a
  reverted block holds has a record here; before the gate they all landed
  on a counter that reports broken preconfirmations;
- a transaction with no record is left alone;
- a nonce held by another live entry is reported and not forced back.

Each was checked by breaking the branch it covers and watching that test,
and only that test, go red.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Every suite here holds one end and a stub of the other. `producer_e2e`
reads frames with a raw websocket client and no consumer; the consumer
suites push hand-built slices straight into a `FlashblocksState` with no
producer; `subscriber_resume` drives a stub server that ignores the resume
parameters it is sent. "Can the consumer read what this producer emits" is
a question none of them asks — which is how a rebuilt block came to blind
the overlay for its whole duration without a test noticing.

Two tests, a real producer node and a real subscriber feeding a real state
bound to the producer's own chain:

- a transaction the producer slices shows up on the consumer's `pending`
  overlay before the block is sealed, which is what the subsystem is for;
- the overlay survives the producer building one height twice. Disabling
  the rebuild classification turns the second red and leaves the first
  green, which is the shape of the defect it guards.

Connecting the two ends turned up why they had drifted. The producer
harness builds with the node's default attributes, which carry no
L1-attributes deposit; the consumer refuses any block without one, and the
consumer suites hand-build that deposit into every base slice to compensate.
So the two fixtures disagreed about what an L2 block contains, and nothing
made them meet. These tests drive the build through `l1_attrs`, the way a
sequencer's blocks actually arrive.

A `Tee` between the socket and the state records `(block, index)` per
slice, so a failure says whether the producer published it or the consumer
could not use it — the same symptom at the overlay, different bugs. It is
what found the deposit mismatch, and it prints the real stream on failure:
`(1,0)…(1,6)` then `(1,0)…(1,10)` across a rebuild.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
fix(ws-proxy): apply the slice ceiling to the frame type the producer sends
`OpTransactionSigned` is a type alias for `OpTxEnvelope`, so converting
between them in the fixture is a no-op clippy refuses. The production call
is generic over `N::SignedTx` and stays.

Found by CI rather than locally: `just clippy` lints `--tests`, and the
scoped `cargo clippy -p <crate> --all-features` used while writing this
does not, so nothing here was ever checked.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
test(preconf): give the reverted-chain pass a fixture it can be read by
`the_overlay_survives_a_second_build_of_one_height` failed about one run in
two under the loaded suite, and passed alone. Two assertions had no wait
behind them: whether the pool had validated an injected transaction in time
for the second build to carry it, and whether the socket had delivered the
restarted slices by the instant `tee.seen()` was read.

Both are gone rather than slowed. The two builds already differ by L1
origin, and that decides the L1-attributes deposit each puts at tx[0] — a
transaction every block is obliged to carry, so the discriminator needs no
pool and no user transaction at all.

That makes the assertion stronger as well as steadier: the overlay must
hold the rebuild's deposit *and not* the abandoned attempt's, which is
exactly the merge-two-builds-onto-one-base defect rather than a proxy for
it. The remaining `tee` read is a poll.

Caught by building the merged state locally before merging: the branch's
own CI was green against the base it was cut from, and this repo runs no
checks on a pull request into `feat/**`, so nothing else would have tried
the combination.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
test(flashblocks): run the producer and the consumer against each other
…ished

Every staleness guard in StateProcessor compared heights only, so a reorg
or a sequencer failover that put a different block at the same height left
the overlay anchored to a block that was no longer canonical. Per-transaction
execution results cached from the abandoned chain were then committed onto
the new chain's state, and `pending` served the result.

base_is_canonical compares the overlay's declared anchor against the chain's
hash at that height, and on any non-match -- different hash, missing height,
or provider error -- drops the snapshot rather than publishing it. It sits in
publish_pending_blocks because that is the single funnel all three build
paths pass through, and it reads the chain on every publish rather than
reacting to notifications: a head rollback whose target has left the engine's
in-memory tree emits none.

The test harness declared B256::ZERO as every slice's parent, which nothing
read until now. It now declares the parent the slice was really built on, and
passes a non-zero declared hash through so a test can still claim one the
chain does not have. Four tests the guard turned red are fixed: one had its
assertion changed because the old one encoded the behaviour this removes, and
three had their setups made to mine before sending so their slices declare a
parent that exists.

The guard is a publish-time check. A snapshot already published keeps being
served until the next publish attempt runs the check again.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…uard

fix(flashblocks): an overlay anchored to a replaced block is not published
One conflict, in mantle-reth/crates/rpc-ext/src/lib.rs: both sides added
imports to the same block. dev brought EIP1186AccountProofResponse and
JsonStorageKey for the eth_getProof geth-parity fix; feat brought Bloom and
the StateOverride/StateOverridesBuilder pair the pending overlay uses for its
state overrides. Resolved as their union — no code from either side dropped.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…d yet

A commitment record outlives its queue entry on purpose: it is what a reorg
consults to put the transaction back, and what the journal keeps a line for.
Three paths were releasing it before the canonical notification that settles
whether it landed, and losing that race is unrecoverable — every later
`mark_committed` is a no-op on a record that is gone.

`unindex` now takes the reason it is being called. Only `Removal::Ended` —
timed out, failed, evicted — releases the record; the paths that merely
observe the chain moving past an entry leave it to `Commitments::sweep`,
which uses the same depth ruler. This covers both the build-start fast path
and `forward_all`, whose comment has long called itself a known gap. It does
not change what `complete_failure` does: a commitment that never landed has
to give its nonce back at once, or the sender is parked behind it.

`note_sealed` is gated on `allow_preconf`. A derivation build executes only
what its attributes name, so claiming the block it seals as "ours" let the
next build's fast path drop entries that block never carried — with nothing
to bring them back, the pool's copy having gone at the slice boundary.

Also here:

- `ReplaceActiveCommitment` no longer names a commitment when the nonce was
  taken by the sender's own pool transaction. The discriminator is not the
  claim kind, which cannot tell the two apart: it is `Replay` with no client
  parked and nothing promised, which is exactly what `stage_executed` makes.
- Journal records carry the `ClaimKind` they were written with, so a restart
  no longer promotes every restored pool transaction to a promise.
- `SlicePacer::settle` refunds the pre-refund figure. An SDM refund returns
  no work to the slice, so settling with the canonical total handed the
  budget back gas that was really spent.
- Counters for the admission refusals that had none, for a journal load that
  fails whole, and for the three ways a slice is dropped without a trace.
  The allowlist miss is the one that matters: a misconfigured list looks,
  from the client's side, exactly like a node ignoring it.
- The whitelist watcher reloads on a dropped notification instead of walking
  past it. Reading `latest()` is idempotent, so an unnecessary refresh is
  free and a missed one is not recoverable.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
`withdrawals_root` is the `L2ToL1MessagePasser` storage root post-Isthmus,
which only means something once a block is sealed. Both sides were
publishing the *parent's* — well-formed, stale on any block containing a
withdrawal, and indistinguishable from a correct answer. Zeroed now, on the
wire and in the pending header, the way `state_root` already is:
`EMPTY_ROOT_HASH` is `0x56e81f17…`, so zero is not a root any state can
produce and cannot be mistaken for one.

Computing the true per-slice value was considered and declined on grounds
of use rather than cost. It is too early for an L1 withdrawal proof,
redundant against the transactions the slice already carries, and not to be
believed without a replay that would compute it anyway. An earlier note left
this open "until a consumer is known to read the field"; one is — it passes
it through to `eth_getBlockByNumber` — and passing a value through is not
using it.

Also here:

- A slice from a build this node never saw the base of no longer extends the
  overlay. Positions repeat across builds, so a continuation could link onto
  the previous build's state and produce a balance no build ever computed.
  It now clears instead: a gap of one block, which the contract allows,
  rather than an answer that was never true.
- The cache drops a height when a new build takes it over, and the replay
  de-duplicates on `(position, payload_id)` rather than position alone.
- `eth_estimateGas` takes `blockOverrides`. It declared three parameters
  where upstream takes four, so a caller's overrides were dropped and the
  estimate came back computed without them, with no error.
- `eth_sendRawTransactionSync` reads `timeout_ms: 0` as unset. Taken
  literally it is a `sleep(0)`, which times the caller out before the
  transaction could land.
- `"UNSAFE"` parses, like every other tag: the delegation below it
  lowercases first, so one visitor had two rules.
- Consumer metrics are pre-registered and named `flashblocks.consumer.*`.
  A counter that has never fired was absent from the scrape rather than
  reported as zero, which Prometheus answers as "no data" —
  indistinguishable from "not scraped", and impossible to alert on. The
  series that matter most are the ones that stay at zero when things work.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The proxy serves the preconfirmation stream — transactions that have been
executed and not yet put on chain. It bound `0.0.0.0` with no keys by
default, and the README's quick-start demonstrated exactly that. It now
refuses to start unless `--api-keys` is set or `--public-access-enabled`
says the surrounding network is the access control. Unauthenticated remains
supported; it just has to be asked for.

Not by changing `--listen-addr`: inside a container, binding loopback means
nothing outside can reach it, `EXPOSE 8545` becomes a lie, and every
deployment sets it back. The exposure boundary there is the Service, not the
process.

**This will stop deployments that run without keys today**, including the
devnet's instance in `rde-v3`, which needs `--public-access-enabled` added.

Nothing in this binary speaks TLS — `tokio-tungstenite` and axum's `ws` are
both pulled in with default features — so both ends are plaintext `ws://`
and an API key travels in the URL path in the clear. That is now said at
startup, in the README, and in the Dockerfile, rather than left to be
discovered. It is also why the two remaining hardening items are deployment
constraints rather than defects: on a plaintext link, guarding against
online key guessing is patching a threat model that no longer holds.

`--upstream-ws` takes one URI. The comma-separated form promised a topology
the proxy does not implement: each subscriber kept its own resume position
and fed one channel with no de-duplication, so a single stream behind two
upstreams was delivered twice and interleaved. Redundancy belongs in front
of the proxy.

Also here:

- A valid customer API key is no longer written to the log. The line sat in
  the *success* branch, and `--enable-filters` is off by default, so an
  ordinary first attempt at the filter route was enough to leak one.
- `--message-buffer-size` defaults to 128. `broadcast::channel` rounds up to
  a power of two, so the old 20 was really 32 — exactly the producer's
  archive, leaving no room for the live slices arriving alongside a replay.
  One overflow disconnects every downstream client, and they have no resume
  to close the gap with.
- Timing flags are refused at startup instead of panicking a task later.
  `--client-pong-timeout-ms` below 4 is the one that mattered: it ticks at a
  quarter of itself, so the per-connection read task died on a zero interval
  while the proxy kept accepting connections and answering `/healthz`.
- The upstream `oneshot` is matched rather than pattern-filtered, so a
  dropped ping task ends the connection instead of panicking on the next
  poll.

The binary now has a build path and a delivery story: `just build-ws-proxy`,
`just docker-build-ws-proxy`, and `DockerfileWsProxy`. It ships as its own
image because it is deployed on its own — a stateless relay, scaled and
restarted independently of any node.

`.gitignore`'s `docs` is anchored to `/docs/`. Unanchored it also matched
vendored directories carrying 87 tracked files, where anything newly added
would have been dropped without a word.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Three warnings from the two commits before this one. CI runs clippy with
`-D warnings`, so each of them would have failed the build — found by
running the gate rather than by it running on us.

`reverted` reads better as the value of the match than as a late-initialised
binding, which is what clippy was pointing at.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…the compile

`cargo test --workspace --lib` never compiles a crate's `main.rs`, so
ws-proxy's seven startup-argument tests ran nowhere while the run kept
printing `N passed`. `--lib --bins` picks them up.

`--retries 2` moves into `.config/nextest.toml` so local and CI runs agree,
and the same file turns on the JUnit report. CI reads it after `just
test-ci` and posts a `::warning` for every test that passed only on a
retry; the report is uploaded as an artifact. Nothing fails on a flaky pass.

The `test` job's 60-minute timeout was measured against eight recent runs
at 50–59 minutes. The time is compilation: the three `-p` invocations in
`test-ci` each resolve features differently from `--workspace` and
recompile a slice of alloy/revm/reth (889 + 317 + 202 crates), while
nextest runs its 267 tests in under three minutes. The timeout goes to 90
and the recipe's comments say what was measured instead of what was hoped.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
…cro for its side

Six `#[ignore]` + `unimplemented!()` tests in `fork_builder.rs` described
EVM scenarios the in-process fixture could never run. Every one of them is
covered against a launched node in `mantle-reth-integration-tests`; the
file now says where each went instead of carrying empty bodies.

The consumer-side `launch_flashblocks_node!` shadowed the producer-side
macro of the same name, telling them apart only by whether the call was
written with a `crate::` prefix. It is now `launch_flashblocks_consumer!`.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
adam-xu-mantle and others added 30 commits November 12, 2026 16:57
fix(flashblocks): carry only changed code in pending state overrides
- reth#27015 release the txpool validation receiver lock before running a job
- reth#27259 notify promoted txs when a parked insertion promotes older ones
- reth#27869 only recover 7702 authorities for this chain or chain_id 0
- alloy#4197 bump alloy-consensus to 2.5.0 to reject 0x00-tagged legacy txs
- moka#592 bump moka to 0.12.16 for the LRU eviction stall fix
- reth#27313 shut down the owned tokio runtime despite live Runtime clones
- reth#26734 refresh storage metrics in the background so scrapes do not block
- tests: with alloy#4197 the optimism#22778 test sees a decode error, so it only checks the rejection (as upstream); reth#27354 stabilizes the vendored hash builder roundtrip test
- revm-inspectors 6ae8f7d4 -> 4a9390b3 (mantle-xyz/revm-inspectors#22); alloy-eip2930 0.2.4
- revm c6df4c5e -> c7be3596 (mantle-xyz/revm#42, #43)
- alloy-eip7928 0.4.11 (revm#3916 needs it; 0.4.12 breaks the pinned engine-tree)
fix: backport upstream trie and proof fixes (v1.7.0)
fix: backport upstream rpc resource fixes (v1.7.0)
fix: backport upstream rpc compatibility fixes (v1.7.0)
fix: backport upstream txpool and misc fixes (v1.7.0)
chore(deps): pick up the merged tracer backports (v1.7.0)
Build with --no-default-features and list the other default features, so
JS tracers are rejected even for callers that reach a node directly.
build(docker): drop js-tracer from the op-reth image
…attempts

docs(ws-proxy): clarify per-app connection attempt metric
Backport ethereum-optimism/optimism#23334 (082e0413) to the v2 store.
Fixes ethereum-optimism/optimism#22501: after an unwind across a history
shard boundary, eth_getProof served chain-tip values for some historical
blocks.
fix(proofs-history): keep v2 history shard keys valid on unwind (v1.7.0)
Brings the v1.6.3 flashblocks fixes: a pending receipt is only served when its
preview extends the canonical head (#238), subblocks subscription aliases
(#242), the combined pending log response limit (#248), pending state overrides
that carry only changed code (#256), and the ws-proxy metric description (#258).
The three fix/revert pairs on v1.6.3 net to nothing; main and the Hoodi BVM
upgrade (#247) were already here.

Conflicts keep the v1.7.0 side: the dependency pins in Cargo.toml, the chain
spec, and the integration test list. #248's log limit is passed in
install_mantle_rpc_extensions, where v1.7.0 moved the flashblocks wiring.
Cargo.lock only gains reth-rpc-eth-types for the integration tests.
sync: merge dev/mantle-v1.6.3 into v1.7.0
Moves the mantle-v2 pin from 1e94ee02 to 8a159aa7, the dev/mantle-v1.7.0
tip after mantle-v2#424. Between the two, rust/ only changes kona's
mantle_hardfork.rs, so no crate reth pins changes. Cargo.lock only changes
the source of the ten mantle-v2 packages.
chore(deps): pin mantle-v2 to its v1.6.3 sync (8a159aa7)
test(trie): verify sparse trie updates in PR CI
Backport paradigmxyz#27313 (d0cb379), including the four shutdown regression tests.
fix(cli): shut down the owned runtime with live handles
test(tasks): fix flaky worker idle assertion
…after-pruning

fix(preconf): restore pending eligibility after slice execution
…l-txpool-conflict

fix(cli): reject flashblock consumers with local transaction retention

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

6 participants