Repository navigation
release: integrate Mantle reth v1.7.0 into main - #236
Open
ivanwang-coder wants to merge 435 commits into
Open
ivanwang-coder wants to merge 435 commits into
ivanwang-coder wants to merge 435 commits into
Conversation
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>
feat flashblocks
…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>
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
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
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:
dev/mantle-v1.7.0@b3953e4ebc2858b8f263a01b6e571c4a82ab7e4b.main@574e7f39f79fbc64ca0881ff8f9229a02ff7a051.Validation already executed for this source tree: full
just prpassed; 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.3integration PR #122 is left unchanged.