Repository navigation
fix(spec): raise FTM250 average_block_time to 3000 ms (MAG-4589) - #199
Conversation
The spec said 1000 ms, but Fantom mainnet produced one block every ~6.6 s over the last hour on 2026-10-22 (from smartrouter_latest_block on gk8). The router's head-stall detector counts "10 block times" from this value, so at 1000 ms a provider one block behind for ~10 s was marked stalled and taken out. That made gk8's only debug add-on provider refuse 13% of debug_traceBlockByHash calls. FTM4002 (testnet) is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
🤖 Spec pipeline started on PR open — running Phase 8 → 11. Results post here as comments. View run |
|
Phase 8 — smart-router boot + multi-node method probe Resumable pipeline run (Phases 8–11), PR #199. Endpoints self-researched (no
|
| Check | Verdict | Evidence |
|---|---|---|
| GET_BLOCKNUM (router latest_block) | OK | smartrouter_latest_block=123783155; rpc_endpoint_fetch_latest_success > 0 on all 3 endpoints (14/14/10 at first sample, climbing); rpc_endpoint_tracker_requests_total{kind="latest_block"} = 434/457/307 after ~5 min |
| GET_BLOCK_BY_NUM (log hash-reads ∥ fetch_block counters) | NOT_EXERCISED (by the automatic tracker cycle) | rpc_endpoint_tracker_requests_total{kind="block_hash"} never appeared (only kind="latest_block" series exist) after 5 min / 400+ latest-block polls; no Chain Tracker Updated block hashes/read a block Hash log lines; no parse-signature lines either. This image's per-endpoint tracker appears to never issue a block_hash-kind request for this chain/config — a router-behavior observation, not a parse-directive defect: the explicit eth_getBlockByNumber method probe below (Step 4) PASSED through the router with a correctly-decoded block (hash, timestamp, number all present and self-consistent), independently confirming the GET_BLOCK_BY_NUM directive/parser is correct. |
| Parse-signature log lines | none | — |
| Verification | Verdict | Providers OK/failed | Notes |
|---|---|---|---|
| chain-id | OK | 3/3 | rawData":"0xfa" matches expected_value on every provider; 5 success lines total (incl. retries during stabilization) |
| pruning | OK | 3/3 | All 3 upstreams return eth_getBlockByNumber("earliest") → number:"0x0", satisfying both the plain latest_distance:128 value and the extension:archive expected_value:"0x0" value; 9 success lines |
| trace (trace-addon collection verification) | OK | 2/2 (only upstream-1/2 carry the trace addon; upstream-3 correctly excluded) |
trace_block returns real result on both; 2 success lines |
No [-] verify failed / failed verification on provider startup lines survive past the boot-stabilization window (all such lines have timestamps strictly before the final Provider validated successfully lines for all 3 providers — transient retry noise during startup negotiation, not a persisting failure).
Addon & extension coverage (Step 1c + probes)
| Name | Type | Upstreams supporting | Standalone | Boot verification | Router probe | Classification |
|---|---|---|---|---|---|---|
| trace | addon | rpcapi.fantom.network, fantom.drpc.org (NOT 1rpc.io/ftm — -32600 Method trace_block not allowed) |
— (ordinary add-on: both trace-supporting upstreams also answer the base collection's eth_blockNumber fine) |
OK | PASS (trace_block, trace_filter, trace_transaction, trace_get all return real results through the router) | TESTED_OK |
| archive | extension | rpcapi.fantom.network, fantom.drpc.org, 1rpc.io/ftm (all 3 — eth_getBlockByNumber("earliest") → block 0x0 on every upstream) |
— | OK | PASS (eth_getBalance at block 0x1 with lava-extension: archive header → result:"0x0") |
TESTED_OK |
Method probe results
Counts: PASS=50 FAIL=9 SKIP=2 UNPROBED=0 WARN=1 TIMEOUT=0 LOG_WARN=0
| Method | Classification | Upstream notes | Notes |
|---|---|---|---|
| dag_getEvent | FAIL | -32601 | method does not exist on this chain's current (Sonic-era) RPC surface; input-independent, no re-probe needed |
| dag_getEventPayload | FAIL | -32601 | same as above |
| dag_getHeads | FAIL | -32601 | same as above |
| eth_accounts | PASS | result: [] |
|
| eth_blockNumber | PASS | GET_BLOCKNUM directive, used as the live-latest source throughout | |
| eth_call | PASS | ||
| eth_chainId | PASS | 0xfa, matches verification |
|
| eth_coinbase | PASS | ||
| eth_compileLLL | FAIL | -32601 | deprecated Solidity-LLL compiler endpoint, removed from all modern clients |
| eth_createAccessList | PASS | ||
| eth_estimateGas | PASS | ||
| eth_feeHistory | PASS | ||
| eth_gasPrice | PASS | ||
| eth_getBalance | PASS | also used for the archive-extension probe | |
| eth_getBlockByHash | PASS | ||
| eth_getBlockByNumber | PASS | GET_BLOCK_BY_NUM directive | |
| eth_getBlockReceipts | PASS | ||
| eth_getBlockTransactionCountByHash | PASS | ||
| eth_getBlockTransactionCountByNumber | PASS | ||
| eth_getCode | PASS | ||
| eth_getCompilers | FAIL | -32601 | deprecated, removed from modern clients |
| eth_getFilterChanges | PASS | first probe hit a stale placeholder filter id (-32600 not allowed); re-probe with a live id from eth_newFilter → result: []; PASS |
|
| eth_getFilterLogs | PASS | same re-probe-once fix as above | |
| eth_getLogs | PASS | ||
| eth_getProof | WARN | -32000 "not available" / "method handler crashed" (varies by upstream) | re-probed with a second address per the re-probe-once gate; failure survives on both attempts and across providers — Fantom's node stack does not implement eth_getProof |
| eth_getStorageAt | PASS | ||
| eth_getTransactionByBlockHashAndIndex | PASS | ||
| eth_getTransactionByBlockNumberAndIndex | PASS | ||
| eth_getTransactionByHash | PASS | ||
| eth_getTransactionCount | PASS | ||
| eth_getTransactionReceipt | PASS | ||
| eth_getUncleByBlockHashAndIndex | PASS | result: null (no uncles on Fantom, expected) |
|
| eth_getUncleByBlockNumberAndIndex | PASS | ||
| eth_getUncleCountByBlockHash | PASS | ||
| eth_getUncleCountByBlockNumber | PASS | ||
| eth_getWork | FAIL | -32601 (first attempt surfaced an HTTP 403 "paid subscription plan... nodies.app" from one rotated upstream; 3x re-probe all returned a clean, input-independent -32601 on every upstream) | not implemented; the 403 was a transient upstream-routing quirk, not the final verdict |
| eth_hashrate | PASS | ||
| eth_maxPriorityFeePerGas | PASS | ||
| eth_mining | PASS | ||
| eth_newBlockFilter | PASS | ||
| eth_newFilter | PASS | also supplied the live filter id used to re-probe eth_getFilterChanges/Logs | |
| eth_newPendingTransactionFilter | PASS | ||
| eth_protocolVersion | FAIL | -32601 | deprecated |
| eth_sign | FAIL | -32601 | not available (no unlocked local accounts on a public endpoint; method itself unimplemented) |
| eth_signTransaction | FAIL | -32601 | same |
| eth_syncing | PASS | ||
| eth_uninstallFilter | PASS | ||
| ftm_currentEpoch | PASS | Fantom-specific method, FTM250's own apis entry |
|
| net_listening | PASS | ||
| net_peerCount | PASS | ||
| net_version | PASS | "250" |
|
| rpc_modules | PASS | ||
| web3_clientVersion | PASS | ||
| web3_sha3 | PASS | ||
| eth_subscribe | PASS | WS probe via ws://localhost:3360, newHeads → subscription id returned, 1 push message received within <1s |
|
| eth_unsubscribe | PASS | result: true |
|
| trace_block | PASS | addon probe | |
| trace_filter | PASS | addon probe | |
| trace_transaction | PASS | addon probe | |
| trace_get | PASS | first probe used a bad param shape (string instead of index array) → -32602; re-probed with [] indices → PASS |
|
| eth_sendRawTransaction | SKIP | stateful — would broadcast a transaction | |
| eth_sendTransaction | SKIP | stateful — would broadcast a transaction |
Log-scan findings (probe window)
Non-benign warn/error/fatal/panic lines logged during probing (Step 4.5). None changed a method's final classification (all are either rate-limit noise, or errors from the FIRST attempt of a method that was fixed by the mandatory re-probe-once gate and already shows PASS above).
| Level | Associated method | error excerpt |
|---|---|---|
| ERR | (fantom-upstream-3) | HTTP 429: Disallowed status code error (429) / NODE_RATE_LIMITED — pacing evidence only, 1rpc.io/ftm rate-limiting under the Step 1c + Step 4 probe burst; no method was left UNPROBED because of it |
| WARN | — | Circuit breaker: all providers exhausted, stopping new attempts × 3 — correlates with the eth_getWork 403/retry storm and one eth_getProof round; resolved on re-probe |
| ERR | eth_getFilterChanges / eth_getFilterLogs (first attempt) | "filter not found" (-32000) — the stale placeholder filter id landed on a provider that never created it (filters are per-node/in-memory, not shared across the 3 rotated upstreams); fixed by the re-probe-once gate using a freshly-created live filter id |
| WARN | eth_getWork | "malformed JSON-RPC response" / "The network of this endpoint requires a paid subscription plan... nodies.app" × 6 — one upstream transiently proxies this specific method to a paid-tier backend; final 3x re-probe across all upstreams converged on a clean -32601 |
| ERR | eth_getProof | "not available" / "method handler crashed" (-32000) on repeated providers — consistent with the WARN verdict above |
| WARN | — | reason:"addon-filtered" extensions:"archive" capable:"0" — a single point-in-time pairing-recalculation snapshot that disagreed with the archive probe's actual PASS result (issued moments apart); treated as router-internal scoring noise, not a defect, since the direct archive-extension call succeeded |
Testnet verification pass (Step 7)
TESTNET_VERIFY: SKIPPED (no live FTM4002 endpoint found)
Searched/probed public FTM4002 (Fantom testnet) endpoints — every one is dead, wrong-network, or keyed:
https://rpc.testnet.fantom.network— no response / connection failurehttps://xapi.testnet.fantom.network/lachesis— no responsehttps://fantom-testnet-rpc.publicnode.com— HTTP 404https://fantom-testnet.drpc.org—{"error":{"message":"Unknown network","code":11}}https://endpoints.omniatech.io/v1/fantom/testnet/public— HTTP 521https://rpc.ankr.com/fantom_testnet— HTTP 401, API key required
Fantom testnet (chain id 4002) appears decommissioned following the Sonic migration. No boot/verification pass was attempted against FTM4002.
Spec note (independent of the above, worth flagging to the orchestrator): the briefing for this phase assumed FTM4002 "inherits from FTM250 and declares no override," but fantom.json shows FTM4002 DOES declare its own explicit average_block_time: 1000 (not inherited, not touched by this PR). So FTM4002's effective block time is 1000 ms, not 3000 ms. This pre-existing testnet value was already stale before this PR (even the old FTM250 default was 1000ms) and is now further out of date given the mainnet empirical measurement below — but since no live FTM4002 endpoint exists, this cannot be verified empirically in this pass.
Empirical block time (Step 8)
Recipe: eth_blockNumber + eth_getBlockByNumber timestamp delta, per the jsonrpc/EVM recipe, sampled across 3 independent upstreams and two window sizes.
| Network | RPC | Window (blocks) | Empirical (ms) | Spec effective (ms) | Drift | Verdict |
|---|---|---|---|---|---|---|
| mainnet (FTM250) | rpcapi.fantom.network | 100 | 6260 | 3000 | +108.7% | BLOCK_TIME_MISMATCH |
| mainnet (FTM250) | fantom.drpc.org | 100 | 6260 | 3000 | +108.7% | BLOCK_TIME_MISMATCH |
| mainnet (FTM250) | 1rpc.io/ftm | 100 | 6410 | 3000 | +113.7% | BLOCK_TIME_MISMATCH |
| mainnet (FTM250) | rpcapi.fantom.network | 1000 (wider window) | 6557 | 3000 | +118.6% | BLOCK_TIME_MISMATCH |
| mainnet (FTM250) | fantom.drpc.org | 1000 (wider window) | 6557 | 3000 | +118.6% | BLOCK_TIME_MISMATCH |
| testnet (FTM4002) | — | — | skipped (no live endpoint) | 1000 (own override, not 3000) | — | skipped |
All 5 independent mainnet samples (3 different upstreams, 2 window sizes) cluster tightly at 6260–6557 ms, averaging ~6410ms. This corroborates the PR body's own claim of ~6600 ms/block measured on an internal dashboard — and sits far above the 3000 ms value this PR sets. The >20% drift rule fires on every single sample: BLOCK_TIME_MISMATCH (mainnet): spec=3000ms empirical=~6260-6557ms (avg ~6410ms). The PR under test appears to have split the difference between the stale 1000ms and the true ~6600ms rather than matching the empirically observed value; a value in the 6200–6600ms range would track the live chain rather than 3000ms.
|
Phase 9 — parallel reviewers (3 independent
All three reports are distinct files with distinct digests (no shared-path overwrite). No finding cited a line number beyond Merged gapsUnanimous CRITICAL — 3/3 reviewers
Raised by 3/3, severity split
MEDIUM / MINOR — pre-existing, outside this PR's one-line diff
Reviewer 1 — full reportSpec Review Gap Report — fantom.json (Reviewer 1)Reviewed: ContextThis is an update PR (branch FindingsCRITICAL-1:
|
| RPC | Window | Empirical (ms) | Spec (ms) | Drift |
|---|---|---|---|---|
| rpcapi.fantom.network | 100 | 6260 | 3000 | +108.7% |
| fantom.drpc.org | 100 | 6260 | 3000 | +108.7% |
| 1rpc.io/ftm | 100 | 6410 | 3000 | +113.7% |
| rpcapi.fantom.network | 1000 | 6557 | 3000 | +118.6% |
| fantom.drpc.org | 1000 | 6557 | 3000 | +118.6% |
This corroborates the PR description's own internal-dashboard figure of ~6600 ms/block. The spec
guide's drift rule (>20% triggers BLOCK_TIME_MISMATCH) fires on every single sample — the PR's
new value (3000 ms) sits almost exactly halfway between the old, too-low value (1000 ms) and the
true empirical value (~6410 ms), rather than matching the live chain.
Impact: average_block_time is the seed value for block_distance_for_finalized_data's
time-based safety margins and for the router's head-stall threshold that this very PR is trying to
fix. Setting it to 3000 ms instead of ~6400–6600 ms means the head-stall window is still ~2.1x too
tight relative to the real chain: a provider that is a single block behind (one real Fantom block
≈ 6.4–6.6 s) can still accumulate "stalled" time faster than the router's 3000ms-scaled tolerance
expects, reproducing a milder version of the exact symptom (debug-addon provider wrongly evicted)
this PR exists to fix.
Recommendation: Set average_block_time to a value in the measured 6200–6600 ms range (e.g.
6400 or 6500 ms) rather than 3000 ms, consistent with the spec guide's rule to "measure on live
network" (Step 2.1) and the >20%-drift threshold.
CRITICAL-2: allowed_block_lag_for_qos_sync (FTM250) was not recomputed after average_block_time changed — this is the PR's own open question
- File/line:
fantom.json:14—"allowed_block_lag_for_qos_sync": 10 - Evidence: The spec guide's formula (Step 2.1 §4) is
10000ms / average_block_time, minimum 1.
allowed_block_lag_for_qos_sync: 10is exactly10000 / 1000— i.e., it was computed for the
oldaverage_block_timeof 1000 ms and was left unchanged when this PR bumped
average_block_timeto 3000 ms. Recomputing against the PR's own new value gives
10000 / 3000 ≈ 3.33, and against the empirically measured ~6410 ms (CRITICAL-1) gives
10000 / 6410 ≈ 1.56. Either way, the current value of 10 is 3–6x higher than the formula
indicates for this chain's real or intended block cadence. The PR body itself raises this exact
parameter as an open review question ("shouldallowed_block_lag_for_qos_syncbe recomputed?"). - Impact: This parameter bounds how far behind a provider's reported block height may lag the
network head before QoS sync penalizes it. Leaving it at 10 whileaverage_block_timetriples
means the absolute tolerated lag window balloons from 10 × 1000ms = 10s to 10 × 3000ms = 30s (or
10 × ~6400ms ≈ 64s if the block time is corrected per CRITICAL-1) — a QoS enforcement regression in
the opposite direction from the bug this PR fixes: instead of evicting providers too aggressively,
the sync-lag check now tolerates providers that are tens of seconds stale. - Recommendation: Recompute
allowed_block_lag_for_qos_synctogether with whichever
average_block_timevalue is finally chosen —ceil(10000 / average_block_time), minimum 1 (e.g.
≈4 ifaverage_block_timestays at 3000; ≈2 if corrected to ~6400–6600 per CRITICAL-1). Do not
ship this PR withaverage_block_timechanged andallowed_block_lag_for_qos_syncleft at its
pre-change value — the two must be recomputed together.
MEDIUM-1: FTM4002 (testnet) declares its own average_block_time: 1000, independently stale and unverifiable
- File/line:
fantom.json:287—"average_block_time": 1000(FTM4002 importsFTM250at
fantom.json:284but overrides this field rather than inheriting FTM250's value) - Evidence:
docs/fantom/METHOD_PROBE_REPORT.md"Testnet verification pass (Step 7)" — every
public FTM4002 endpoint probed is dead, wrong-network, or keyed (rpc.testnet.fantom.networkno
response,xapi.testnet.fantom.network/lachesisno response,fantom-testnet-rpc.publicnode.com
404,fantom-testnet.drpc.org"Unknown network",endpoints.omniatech.ioHTTP 521,
rpc.ankr.com/fantom_testnetHTTP 401 keyed). The report concludes Fantom testnet (chain id 4002)
"appears decommissioned following the Sonic migration." This pre-existing value was already
untouched (and unverified) before this PR, and remains unverifiable now — it was not based on the
same stale 1000ms default FTM250 used to carry, since FTM4002 was never changed to inherit it, but
there is no live chain to confirm whether 1000ms is or ever was correct for testnet. - Impact: Low immediate impact since the network appears to have no live, publicly reachable
RPC to serve traffic against; but the spec entry remains"enabled": truewith an unverifiable,
likely-stale block-time parameter and its three derived values (block_distance_for_finalized_data: 0,blocks_in_finalization_proof: 1,allowed_block_lag_for_qos_sync: 10— the latter is at least
internally consistent with its own 1000ms value,10000/1000=10, unlike FTM250's).
If a provider ever stakes against FTM4002 with a privately-run or non-standard testnet endpoint,
the lag/finality assumptions would be untestable against the public network. - Recommendation: Out of scope for this PR (FTM4002 is explicitly untouched), but flag for a
follow-up: either confirm FTM4002 is genuinely dead and consider disabling the spec entry, or
obtain a working endpoint and re-run the empirical block-time measurement before trusting
average_block_time: 1000.
MEDIUM-2: FTM250's trace collection overrides deterministic: true on APIs that ETH1 (the imported parent) marks deterministic: false
- File/line:
fantom.json:193-252—trace_block(line ~193,deterministic: true),
trace_transaction(line ~223,deterministic: true),trace_get(line ~238,
deterministic: true); onlytrace_filter(line ~208) keepsdeterministic: false. - Evidence: ETH1's own
traceadd-on collection (ethereum.json) defines
trace_block,trace_get,trace_transaction, andtrace_filterall with
category.deterministic: false. Because FTM250 importsETH1and re-defines these same API
names inside its ownadd_on: "trace"collection, merge semantics (spec guide Step 3.1a: "APIs —
differentiatorName— child version wins") mean FTM250'sdeterministic: trueoverrides
ETH1'sfalsefor three of the four trace methods, with no comment explaining the divergence. - Impact:
deterministic: trueenables cross-provider data-reliability comparison (VRF-based
equivocation checks) — if different Fantom node implementations/versions format trace output
slightly differently for the same block/tx (a known general risk with debug/trace RPCs, which is
presumably why ETH1 itself marks them non-deterministic), providers could be incorrectly flagged
for serving conflicting data on fully correct trace responses. The probe report's trace tests
(Step 1c / Step 4) only confirm the calls return a real result on 2/3 upstreams — they do not
test byte-for-byte agreement between upstreams, so this risk has not been empirically ruled out. - Recommendation: Verify whether Fantom's trace output is in fact stable across the node
implementations providers are expected to run; if not verified, prefer matching ETH1's
deterministic: falsefortrace_block/trace_transaction/trace_getrather than silently
overriding it.
MINOR-1: dag_getEvent / dag_getEventPayload use EMPTY block-parsing where the analogous ETH1 pattern uses DEFAULT
- File/line:
fantom.json:56-85—dag_getEventPayloadanddag_getEvent, both
"block_parsing": {"parser_arg": [""], "parser_func": "EMPTY"} - Evidence: Per the spec guide,
EMPTYis for "no block parameter, static/immutable data" or
"pure computation, no chain state." These two methods fetch an actual DAG event by ID/hash —
structurally the same shape aseth_getTransactionByHash/eth_getBlockByHash, which the
imported ETH1 parent spec configures asDEFAULTwithparser_arg: ["latest"](confirmed in
ethereum.json), notEMPTY, precisely because the result reflects real chain state even though
the request carries no explicit block parameter. - Impact: Minor/theoretical —
docs/fantom/METHOD_PROBE_REPORT.mdmethod-probe results classify
all threedag_*methods (dag_getEvent,dag_getEventPayload,dag_getHeads) asFAIL -32601,
"method does not exist on this chain's current (Sonic-era) RPC surface." Per the reviewer's
instructions, a probe-only-32601is not sufficient positive evidence to recommend disabling
these APIs, so they are not flagged for removal here — but if they are ever restored for a
pre-Sonic / Lachesis-era client, theblock_parsingshould probably match the hash-lookup
convention (DEFAULT/latest) rather thanEMPTY, for consistency with how the rest of the
spec's inherited ETH1 collection treats equivalent lookup-by-ID methods. - Recommendation: Low priority given the methods are currently non-functional on the live
network; revisit if/whendag_*methods are confirmed reachable again.
Not flagged (settled / explicitly out of scope)
- Absence of
title/description/depositand the nine removed governance fields — correct, per
current model (settled decision a). blocks_in_finalization_proof: 1on both FTM250 and FTM4002 — correct for Fantom/Opera's aBFT
near-instant finality (settled decision b).block_distance_for_finalized_data: 0on both entries — consistent with the repo-wide convention
for instant/BFT-finality chains (verified against ~50 other specs in this repo, e.g. Cosmos SDK
chains, Aptos, Solana, which all pairblock_distance_for_finalized_data: 0with
blocks_in_finalization_proof: 1); not a defect.dag_getEvent,dag_getEventPayload,dag_getHeads, andeth_getProof/eth_getWork/etc.
FAIL/WARNprobe results — not flagged for disabling; probe-only evidence is insufficient per
review instructions (settled decision c). No documentation was available in this pass to establish
positive evidence of removal/unsupport.- Phase 0 removed-field guard: PASS, no
REMOVED_FIELDhits infantom.json. - Parse directives (
GET_BLOCKNUM,GET_BLOCK_BY_NUM,GET_EARLIEST_BLOCK,SUBSCRIBE,
UNSUBSCRIBE) — all present, correctly templated, and independently confirmed working by the
probe report (Step 3.5, Step 4:eth_getBlockByNumberPASSED through the router with a
correctly-decoded block). - Chain-id verifications —
0xfa(FTM250, = 250 decimal) and0xfa2(FTM4002, = 4002 decimal) are
both correct and, for FTM250, confirmed live by the probe report (3/3 providers matched). - Pruning verification /
archiveextension (cu_multiplier: 5,rule.block: 127,
latest_distance: 128) — confirmed working live (probe report: 3/3 providers, 9 success lines).
Summary
- Endpoints reviewed: 4 FTM250-specific APIs (
ftm_currentEpoch,dag_getHeads,
dag_getEventPayload,dag_getEvent) + 4trace-addon APIs (trace_block,trace_filter,
trace_transaction,trace_get) defined directly infantom.json, plus the full inherited ETH1
base/debug/trace/bundler surface (~58 methods actually exercised per the method probe report: 50
PASS, 9 FAIL, 1 WARN, 2 SKIP). - Gaps by severity: CRITICAL = 2, MEDIUM = 2, MINOR = 1.
- Deployment readiness: The PR's stated fix (raising
average_block_timeoff of the
unconditionally-wrong 1000ms) is directionally correct but the new value (3000ms) is itself still100% off the empirically measured live chain (~6410ms average), and the directly-dependent
allowed_block_lag_for_qos_syncparameter was not recomputed at all — both CRITICAL findings
should be resolved (ideally in this same PR, since they are the same category of bug) before this
ships. The MEDIUM/MINOR findings are pre-existing, out of this PR's direct diff, and can be tracked
separately.
Reviewer 2 — full report
Fantom (fantom.json) — Spec Review Gap Report (Reviewer 2)
Scope: Review of fantom.json (FTM250 mainnet, FTM4002 testnet) in the context of PR #199 /
MAG-4589, which raises FTM250's average_block_time from 1000 ms → 3000 ms to fix a router
head-stall false-positive that was removing the only debug-addon provider on a cluster.
This review also incorporates the empirical findings of docs/fantom/METHOD_PROBE_REPORT.md
(Phase 8 live block-time measurement, Step 1c/4 method probes, boot-verification results).
No removed fields were found: check_unused_fields.sh fantom.json → RESULT: PASS (no removed fields), exit 0. All internal_path values are "", so the internal-path guard does not apply.
CRITICAL
1. average_block_time: 3000 (FTM250) is still ~2.1x off from the live chain
- File/line:
fantom.json:13 - Evidence:
docs/fantom/METHOD_PROBE_REPORT.mdStep 8 measured Fantom mainnet empirically
across 5 independent samples (3 upstreams —rpcapi.fantom.network,fantom.drpc.org,
1rpc.io/ftm— and 2 window sizes, 100 and 1000 blocks): 6260–6557 ms per block, average
~6410 ms. Every single sample triggers the repo's ownBLOCK_TIME_MISMATCHrule
(>20% drift):spec=3000ms empirical=~6260-6557ms (avg ~6410ms), i.e. +108.7% to +118.6% drift.
This corroborates the PR body's own claim of ~6600 ms/block from an internal dashboard. - Impact: This PR was written to fix a router head-stall false-positive caused by
average_block_timebeing too low (1000 ms, so a provider one block behind — i.e.
~1-6.5s "late" on the real chain — got marked stalled and pulled from rotation, taking the
onlydebug-addon provider on its cluster offline). Setting it to 3000 ms halves the
original error but does not fix it: at the true ~6400-6600 ms cadence, a provider that is
genuinely only one block behind is still ~3.4-3.6s further "late" than the spec believes,
which is most of the way back to the original 1000 ms bug's symptom. The router's head-stall
threshold is derived from this value, so the same class of false-positive (healthy provider
marked stalled, including — again — any singledebug-addon provider on a cluster) remains
very plausible at 3000 ms. - Fix: Set
average_block_timeto a value in the measured ~6200-6600 ms range (e.g. 6500 ms,
matching the convention used by other near-instant-finality chains at comparable cadence —
see finding MEDIUM-1 below) rather than splitting the difference between the stale 1000 ms and
the empirical ~6410-6600 ms.
MEDIUM
1. allowed_block_lag_for_qos_sync was not recalculated when average_block_time changed
- File/line:
fantom.json:14(allowed_block_lag_for_qos_sync: 10), paired with
fantom.json:13(average_block_time: 3000) - Evidence: The formula is
10000ms / average_block_time, minimum 1. The repo's own chains
follow this closely for Cosmos/BFT-style chains at comparable block times — e.g.
tendermint.json/osmosis.json/cosmoshub.jsonataverage_block_time: 6500all use
allowed_block_lag_for_qos_sync: 2(ceil(10000/6500)=2);akash.jsonat 6000/5859 also uses
2. FTM250's own pre-PR value (average_block_time: 1000→allowed_block_lag_for_qos_sync: 10) matched the formula exactly (10000/1000=10). The PR changedaverage_block_timeto 3000
but leftallowed_block_lag_for_qos_syncat10, which no longer matches the formula
(ceil(10000/3000)=4), and would be2at the empirically-correct ~6500 ms (CRITICAL-1 above). - Impact:
allowed_block_lag_for_qos_syncis the QoS freshness tolerance — leaving it at10
makes the router ~2.5-5x more lenient than the formula intends about how many blocks behind a
provider may be before it's penalized on sync QoS, independent of the head-stall mechanism
CRITICAL-1 addresses. This is a second parameter that silently drifted out of the spec's own
internal formula as a side effect of this PR's one-line change. - Fix: Recompute
allowed_block_lag_for_qos_syncalongsideaverage_block_time(→2if
average_block_timeis corrected to ~6500 ms per CRITICAL-1;4if kept at3000).
2. dag_getHeads block parsing uses DEFAULT but the method takes an explicit epoch argument
- File/line:
fantom.json:41-54(block_parsing.parser_func: "DEFAULT",parser_arg: ["latest"]at lines 42-47) - Evidence: Per the go-opera wiki API reference
(https://github.com/Fantom-foundation/go-opera/wiki/API),dag_getHeadstakes one parameter —
a HEX-encoded epoch number, or the strings"latest"/"pending"— at params position 0. This
is structurally identical toeth_getBlockByNumber's block-number argument, which the spec
(and ETH1) correctly parses withPARSE_BY_ARG,parser_arg: ["0"](fantom.json:96,
ethereum.json).dag_getHeadsinstead usesDEFAULT, which always tags the request as
"latest" regardless of what epoch the caller actually passed. - Impact: A consumer calling
dag_getHeadsfor a specific (non-latest) epoch has that
request mis-tracked as a "latest" request for block-association/data-reliability purposes,
which can misattribute staleness/QoS scoring and bypass the finalization-distance logic that
would otherwise apply to a historical-epoch query. - Fix: Change to
{"parser_arg": ["0"], "parser_func": "PARSE_BY_ARG"}.
3. dag_getEvent / dag_getEventPayload use EMPTY, inconsistent with the spec's own precedent for hash-keyed lookups
- File/line:
fantom.json:56-69andfantom.json:70-84(block_parsing.parser_func: "EMPTY",parser_arg: [""]) - Evidence: Both methods take an event-hash/ID parameter, not a block number — structurally
the same shape aseth_getTransactionByHash,eth_getBlockByHash, and
eth_getTransactionReceipt. ETH1 (inherited by this spec) classifies all three of those as
DEFAULT/parser_arg: ["latest"], notEMPTY— i.e. the established convention in this
codebase for "look up an immutable object by hash" is to tag the request against the current
head for freshness/QoS tracking, not to exempt it entirely viaEMPTY.dag_getEvent/
dag_getEventPayloadbreak that precedent. - Impact: Tagging these as
EMPTYmeans a provider that hasn't yet synced the event in
question (e.g. one a few seconds behind head) is never penalized for returning "not found" —
the request isn't associated with any block for staleness scoring, unlike the equivalent
eth_getTransactionByHashcase. - Fix: Align with the
eth_getTransactionByHash/eth_getBlockByHashprecedent:
{"parser_arg": ["latest"], "parser_func": "DEFAULT"}.
4. eth_getProof (inherited from ETH1) is not overridden/disabled, but Fantom's current (Sonic) node client does not support it
- File/line: not present in
fantom.json— the gap is the absence of an override in
FTM250'sadd_on: ""collection (fantom.json:16-182);eth_getProofis inherited unmodified
fromethereum.json's main collection. - Evidence:
docs/fantom/METHOD_PROBE_REPORT.mdclassifieseth_getProofas WARN:
-32000 "not available"/"method handler crashed", reproduced on a second address and
surviving across multiple upstream providers (not a single-provider fluke). This is
corroborated by published documentation with a URL, satisfying the bar for a positive-evidence
disable (not just a probe failure): https://docs.chainstack.com/reference/fantom-getproof
states "The Sonic node client no longer supportseth_getProoffor the Fantom chain." - Impact: Every provider serving FTM250 inherits
eth_getProofas enabled, but the method
will fail on any current (Sonic-era) node, degrading relay-success-rate QoS for a method that
can never succeed on this chain. - Fix: Define the
add_on: ""collection override{"name": "eth_getProof", "enabled": false}in FTM250 (Evmos-pattern selective disable, perSPEC_GUIDE.mdStep 3.3b).
5. FTM4002 testnet's own average_block_time: 1000 is unverified and likely stale, independent of this PR
- File/line:
fantom.json:287(average_block_time: 1000),fantom.json:279-314
(FTM4002 spec block) - Evidence: FTM4002 does not import FTM250's
average_block_time— it declares its own
explicit1000(imports only bring inherited API collections/parse directives/verifications
per the merge rules inSPEC_GUIDE.mdStep 3.1a; top-level scalar fields like
average_block_timeare not inherited at all and must be set per-spec). This value was never
touched by this PR and pre-dates it. Perdocs/fantom/METHOD_PROBE_REPORT.md's Step 7
testnet-verification pass, every public FTM4002 endpoint tried was dead, wrong-network, or
behind a paywall; "Fantom testnet (chain id 4002) appears decommissioned following the Sonic
migration," so this value could not be empirically re-measured in this pass.
allowed_block_lag_for_qos_sync: 10(fantom.json:288) is at least internally consistent with
average_block_time: 1000(10000/1000=10), so unlike FTM250 there is no internal formula
drift here — only a plausibly-stale absolute value. - Impact: If FTM4002 is still reachable by any provider, its block-time-derived
head-stall/QoS thresholds inherit the same category of risk this whole PR exists to fix for
mainnet, and cannot currently be validated either way. - Fix: No action possible without a live endpoint; flagging for whoever next touches this
spec with testnet access, or for removal consideration if the testnet is confirmed
decommissioned.
6. Native Fantom abft_* RPC namespace is entirely missing from the spec
- File/line: FTM250's
add_on: ""collection,fantom.json:16-182(onlyftm_currentEpoch
and the threedag_*methods are present) - Evidence: The go-opera wiki (https://github.com/Fantom-foundation/go-opera/wiki/API)
documents three additional native, non-standard-Ethereum methods that this spec omits
entirely:abft_getDowntime,abft_getEpochUptime,abft_getOriginatedFee(all take a
validator-ID integer parameter and return aBFT/Lachesis validator performance metrics). These
are the same kind of chain-specific extension as the already-includedftm_*/dag_*methods
— not deprecated, not platform-specific, not on a different server. - Impact: Consumers needing validator uptime/downtime/fee data (e.g. staking dashboards,
validator-monitoring tooling) have no path to this data through the Fantom spec at all. - Fix: Add an
abft_*API entry set to the main collection, e.g.compute_units: 10
(simple validator-keyed reads, no block param —parser_func: "DEFAULT"/parser_arg: ["latest"]by the same reasoning as MEDIUM-3, since results are scoped to "current epoch"),
category: {"deterministic": false, "stateful": 0}(uptime/downtime are live-accumulating
counters, not point-in-time deterministic facts).
MINOR
1. trace_block / trace_transaction / trace_get determinism diverges from ETH1's baseline without explanation
- File/line:
fantom.json:193-206(trace_block),fantom.json:223-236
(trace_transaction),fantom.json:238-251(trace_get) — all"deterministic": true - Evidence:
ethereum.json's inheritedtracecollection marks all four trace methods
(trace_block,trace_filter,trace_transaction,trace_get) as"deterministic": false.
Fantom's override collection flips three of the four totrue(onlytrace_filteris left
false, matching ETH1). Arguablytrueis the more technically correct choice for a
historical-block opcode trace (same block → same trace, every time), but the inconsistency
with the established ETH1 baseline is undocumented, and the CU-table guidance says to cross
check against ETH1 for consistency across the network. - Impact: Low — likely improves rather than harms data-reliability behavior, but a reviewer
cross-referencing against ETH1 should understand why Fantom diverges here. - Fix: Either leave as-is with a short justifying comment/PR note, or align with ETH1's
falsefor network-wide consistency.
2. dag_getEvent / dag_getEventPayload CU values don't distinguish payload weight
- File/line:
fantom.json:56-69(dag_getEventPayload,compute_units: 20),
fantom.json:70-84(dag_getEvent,compute_units: 20) - Evidence: Per go-opera docs,
dag_getEventexplicitly returns the event without
transactions, whiledag_getEventPayloadreturns the event with full transaction data (or
just hashes, depending on a boolean flag) — i.e.dag_getEventPayloadis strictly the heavier
of the two calls, analogous to howeth_getBlockByHash(false)vs. a full-transaction block
fetch might warrant different CU. Both are currently priced identically at 20 CU.
dag_getHeads(lighter, returns only an array of IDs) is correctly priced lower at 10 CU. - Impact: Negligible economic effect at these CU magnitudes; included for completeness per
the CU-accuracy checklist. - Fix: Consider
dag_getEvent: 10, leavingdag_getEventPayload: 20.
3. Probe coverage did not exercise the debug add-on, despite it being the direct motivation for this PR
- File/line: n/a (probe-completeness observation, not a spec defect) —
docs/fantom/METHOD_PROBE_REPORT.mdmethod-probe table covers only the main collection, plus
trace/archive; FTM250'sdebugcollection (11 APIs, inherited wholesale from
ethereum.json, e.g.debug_traceBlock,debug_traceTransaction) was never probed or boot-
verified in this pass. - Evidence: PR fix(spec): raise FTM250 average_block_time to 3000 ms (MAG-4589) #199's own stated motivation is that a head-stall false positive "took out
the onlydebug-addon provider on a cluster" — i.e. thedebugadd-on is in active production
use on Fantom. No empirical evidence in this review pass confirms the inherited ETH1debug
collection actually works against a live Fantom (Sonic) node. - Impact: None to the spec itself (ETH1's
debugcollection is inherited automatically per
the spec's own correct omission of adebugoverride, which is the right pattern per
SPEC_GUIDE.mdStep 3.1a) — this is a gap in verification coverage, not a spec bug. - Fix: If another probe pass is run against this chain, include the
debugadd-on given its
direct relevance to the bug this PR fixes.
Summary
- Endpoints/parameters reviewed: both
api_collectionsin FTM250 (add_on: ""— 4
chain-specific APIs plus the full inherited ETH1 main/debug/bundler surface;add_on: "trace"
— 4 APIs merged with ETH1's trace collection) plus FTM4002's override block; all 4 network
timing parameters; both verifications (chain-id,pruning) plus the trace-collection's
trace/inheritedpruning; thearchiveextension; all 4 parse directives
(GET_BLOCKNUM/GET_BLOCK_BY_NUM/GET_EARLIEST_BLOCK/SUBSCRIBE/UNSUBSCRIBE); cross-
checked againstdocs/fantom/METHOD_PROBE_REPORT.md's 61-method live probe and Step 8
empirical block-time measurement. - Gaps found: 1 CRITICAL, 6 MEDIUM, 3 MINOR.
- Readiness: The spec is not ready to merge as-is. The PR's stated goal (stop the
router from falsely marking a one-block-behind provider as stalled) is only partially achieved
byaverage_block_time: 3000— the live chain runs at ~6400-6600 ms/block (CRITICAL-1), so the
same failure mode this PR exists to fix remains plausible at the proposed value. At minimum,
average_block_timeshould be moved into the empirically measured range and
allowed_block_lag_for_qos_syncrecalculated to match (MEDIUM-1) before this merges.
Reviewer 3 — full report
Spec Review: fantom.json (Reviewer 3)
Context
This review covers fantom.json as it stands on branch fix/ftm250-block-time (PR #199), which
changes exactly one value: FTM250 average_block_time 1000 → 3000 ms (MAG-4589), to fix a
router head-stall false-positive. No API docs or credentials were supplied for this pass; findings
are derived from the spec file itself, the spec guide, cross-checks against ethereum.json (ETH1,
the import parent), and docs/fantom/METHOD_PROBE_REPORT.md (live router boot + method probes +
Step 8 empirical block-time measurement).
Phase 0 removed-field guard: check_unused_fields.sh fantom.json → PASS, no removed fields, no
internal_path usage. Canonical { "proposal": { "specs": [...] } } envelope confirmed, no
title/description/deposit.
Findings
1. [CRITICAL] average_block_time: 3000 is still ~2.1x too low — spec value doesn't match the live chain
File: fantom.json, FTM250, line 13 ("average_block_time": 3000)
Evidence: docs/fantom/METHOD_PROBE_REPORT.md Step 8 measured Fantom mainnet empirically
5 independent times (3 upstreams: rpcapi.fantom.network, fantom.drpc.org, 1rpc.io/ftm; 2
window sizes: 100 and 1000 blocks) via the eth_blockNumber + eth_getBlockByNumber timestamp-delta
recipe. All 5 samples cluster tightly at 6260–6557 ms, averaging ~6410 ms. Every sample
trips the >20% drift rule: BLOCK_TIME_MISMATCH: spec=3000ms empirical=~6260-6557ms. The probe
notes this corroborates the PR body's own internal-dashboard figure of ~6600 ms/block.
Impact: The PR's stated motivation is that the router derives its head-stall threshold from
average_block_time, and the old 1000 ms value caused a provider one block behind (~1 block *
true ~6.4s block time ≈ 6.4s lag) to be misclassified as stalled and pulled from rotation. Setting
average_block_time to 3000 ms halves the true block interval, so the router's stall/lag math is
still derived from a value roughly 2x faster than reality — the same class of problem the PR exists
to fix, just less severely than at 1000 ms. A provider that is one real block behind is lagging
~6.4s in wall-clock time, which the router will interpret as being over two of its assumed
3000 ms-blocks behind, re-introducing (in attenuated form) the original false-stall risk this PR
is meant to resolve.
Recommendation: Set average_block_time to a value that tracks the live chain — the probe's
own conclusion is that something in the 6200–6600 ms range (not 3000 ms) matches observed behavior.
2. [MEDIUM] allowed_block_lag_for_qos_sync: 10 was not recalculated alongside average_block_time
File: fantom.json, FTM250, line 14
Evidence: Per the spec guide (Step 2.1), this field follows 10000ms / average_block_time
(minimum 1). At the old average_block_time of 1000 ms, 10000/1000 = 10 — an exact match for
the value currently in the file. The PR changed average_block_time to 3000 ms but left this
field at 10; recomputed, 10000/3000 ≈ 3.33. The value in the spec is the stale artifact of the
pre-PR block time, not a value computed against the new one.
Impact: This field feeds Lava's QoS-sync-lag tolerance (how many blocks of lag are tolerated
before a provider is marked out of sync for QoS scoring purposes) — a separate mechanism from the
head-stall logic PR #199 targets, but derived from the same average_block_time input and subject
to the same "stale after a block-time edit" failure mode. Leaving it at 10 makes the QoS-sync
tolerance ~3x looser than the formula intends (≈30s of tolerated lag instead of ≈10s at the new
3000 ms setting, or ≈19-20s of tolerated lag at a corrected ~6400ms setting) — not immediately
destabilizing, but an inconsistency that should be fixed in the same change that corrects
average_block_time, since it was evidently meant to track it.
Recommendation: Recompute this value once average_block_time is corrected (finding #1).
3. [MEDIUM] trace_block / trace_transaction / trace_get deterministic flag diverges from the ETH1 baseline for the same methods
File: fantom.json, FTM250 trace collection, lines 192–251
Evidence: FTM250 marks trace_block, trace_transaction, and trace_get as
category.deterministic: true. The parent ethereum.json (ETH1), which defines the identical
trace_* JSON-RPC methods (same OpenEthereum/Parity-style tracing API, same semantics, same
200 CU), marks all four trace methods including these three as deterministic: false. Only
trace_filter matches between the two specs (false in both). Compute units for all four methods
do match ETH1 (200 CU each), so this isn't a wholesale re-authoring — just the determinism flag
diverges on exactly these three.
Impact: deterministic governs whether Lava treats an API's response as suitable for
cross-provider VRF-style data-reliability verification (same request/block ⇒ byte-identical
response expected across independently-operated providers). ETH1's false on these methods
reflects a known real-world property of execution tracing: different client builds/versions can
emit structurally different (but equally valid) trace output for the same block/tx, which would
make true cause spurious cross-provider reliability-check failures. There is no documented reason
Fantom's implementation of the same trace_* module would be exempt from that property. Marking
it true risks false-positive reliability failures on otherwise-healthy providers.
Recommendation: Align trace_block, trace_transaction, trace_get to deterministic: false
to match the ETH1 baseline, unless there is documented evidence that Fantom/Opera's trace module
is byte-for-byte reproducible across independent node implementations (not shown in the probe).
4. [MEDIUM] dag_getEvent / dag_getEventPayload / dag_getHeads are enabled: true but consistently absent from the current RPC surface across 3 independent upstreams
File: fantom.json, FTM250 main collection, lines 41–84
Evidence: docs/fantom/METHOD_PROBE_REPORT.md method-probe table classifies all three as
FAIL -32601, noting: "method does not exist on this chain's current (Sonic-era) RPC surface;
input-independent, no re-probe needed." Unlike most of the probe's other -32601/-32000
findings (which the task's settled decisions rightly treat as free-tier-node noise, not spec
defects), this failure is consistent and input-independent across three independently-operated
upstreams (rpcapi.fantom.network, fantom.drpc.org, 1rpc.io/ftm) — i.e., three different node
operators' implementations all agree the method doesn't exist, not one rate-limited free endpoint.
Impact: These are Fantom/Lachesis-DAG-specific methods (pre-Sonic consensus internals); if the
Sonic upgrade removed the dag_* namespace from the node client itself, keeping them enabled: true
means the spec commits providers to serving APIs that no current Fantom node implementation
actually exposes.
Recommendation: Verify against go-opera/Sonic release notes or source for whether dag_* RPC
methods were removed; if confirmed, disable these three APIs for FTM250. (Flagged at MEDIUM rather
than CRITICAL because — per the review's standing guidance — probe failures alone don't mandate
disabling without positive client-level evidence; this is close to that bar given 3-upstream
agreement, but a documentation/source citation would make it conclusive.)
5. [MINOR] eth_getProof (inherited from ETH1) — probe WARN, worth a documented check
File: fantom.json — not defined locally; inherited enabled: true from ETH1's main collection.
Evidence: Probe classifies eth_getProof as WARN: consistent -32000 ("not available" /
"method handler crashed") across upstreams, surviving the mandatory re-probe-once gate with a
second address, on every provider.
Impact/recommendation: Per this review's settled guidance, a probe failure alone (even a
WARN that survived re-probing) isn't sufficient grounds to disable without positive evidence the
chain's node-client lacks the method. Noting this for the spec owner to check against Fantom/Opera
client documentation; if eth_getProof is confirmed unsupported by go-opera, add a Fantom-specific
override (enabled: false) in FTM250's main collection — leave ETH1 and other EVM chains untouched.
Not blocking.
6. [MINOR] Unnecessary byte-for-byte re-declaration of inherited ETH1 fields
File: fantom.json, FTM250 main collection — parse_directives (lines 88–135), the chain-id
verification's parse_directive (lines 139–150), the pruning verification (lines 157–171), and
the archive extension (lines 173–181).
Evidence: Diffing against ethereum.json's ETH1 main collection, every one of these blocks is
byte-identical to the parent's: same GET_BLOCKNUM/GET_BLOCK_BY_NUM/GET_EARLIEST_BLOCK/
SUBSCRIBE/UNSUBSCRIBE templates and parsers, same chain-id verification shape (only
expected_value differs, which is the one override FTM250 actually needs), same pruning values
(latest_distance: 128, extension: archive / 0x0), same archive extension (cu_multiplier: 5,
rule.block: 127).
Impact: Per the spec guide's merge semantics (Step 3.1a), none of this needed to be
re-declared — FTM250 imports ETH1 and would inherit all of it automatically via merge even with
these fields omitted (or left as empty arrays). This is "Mistake 1" from the guide's own
common-mistakes list: copying inherited content verbatim creates a maintenance hazard — if ETH1's
directive templates, encoding, or pruning/archive conventions are updated upstream, FTM250 will
silently keep the stale pinned copy instead of inheriting the fix.
Recommendation: Not urgent (values currently match exactly, so there's no live bug), but worth
trimming to just the genuinely Fantom-specific pieces (the chain-id expected_value override,
the chain-specific apis, and the trace verification) the next time this spec is touched.
7. [MINOR / informational] FTM4002 testnet: unverifiable, independently-declared average_block_time, possible decommissioned network
File: fantom.json, FTM4002, line 287 ("average_block_time": 1000)
Evidence: FTM4002 imports FTM250 but declares its own explicit average_block_time: 1000 —
it does not inherit FTM250's value (confirmed: verification-only override pattern is correctly
used for chain-id, but average_block_time is a top-level spec field, set independently, not
subject to collection-merge semantics at all). This PR does not touch it. The probe's Step 7 found
no live FTM4002 endpoint among 6 candidates tried (rpc.testnet.fantom.network,
xapi.testnet.fantom.network/lachesis, fantom-testnet-rpc.publicnode.com,
fantom-testnet.drpc.org, endpoints.omniatech.io/.../fantom/testnet/public,
rpc.ankr.com/fantom_testnet) — all dead, wrong-network, HTTP-error, or key-gated — suggesting the
testnet may be decommissioned following the Sonic migration.
Impact: This value was already stale before this PR (even the old FTM250 mainnet default was
1000ms, and testnet block times are usually faster than mainnet, not equal) and cannot currently be
empirically verified one way or the other. Out of scope for this PR's single-value change, but
worth a follow-up: either confirm a live FTM4002 endpoint exists and re-measure, or flag the testnet
entry as likely-dead so a future reviewer doesn't spend time tuning a value for a network that no
longer answers.
Non-findings (verified correct / addressed by probe evidence)
GET_BLOCK_BY_NUMdirective correctness: the probe's Step 3.5 notes the router's automatic
tracker cycle never issued ablock_hash-kind request during the ~5-minute observation window
(NOT_EXERCISED). This is a router-runtime-behavior quirk, not a spec defect: the explicit
eth_getBlockByNumbermethod probe (Step 4) independently PASSED through the router with a
correctly-decoded, self-consistent block (hash/timestamp/number all present), confirming the
GET_BLOCK_BY_NUMfunction_template/result_parsing(PARSE_CANONICAL,parser_arg: ["0","hash"],
encoding: hex) is correct. No action needed onfantom.json.GET_BLOCKNUM,GET_EARLIEST_BLOCK,SUBSCRIBE,UNSUBSCRIBE: all probe PASS/OK, and all
byte-match the proven-correct ETH1 parent shapes.- Verifications
chain-id(0xfa),pruning(latest_distance: 128/ archive0x0), and
trace(expected_value: "*") — all probe OK/PASS, 3/3, 3/3, and 2/2 (upstream-3 correctly
excluded from the trace check, as it doesn't carry thetraceaddon). block_distance_for_finalized_data: 0andblocks_in_finalization_proof: 1— consistent
with Fantom/Opera's aBFT near-instant finality model and with the repo-wide convention for
instant/BFT-finality chains (cross-checked against ~15 other instant-finality specs in the repo,
e.g.near.json,base.json,optimism.json, and the broader Cosmos-SDK family, all of which use
block_distance_for_finalized_data: 0withblocks_in_finalization_proof: 1for fast/instant
finality chains). Per this review's settled guidance, not a finding.- Governance/envelope fields (
title,description,deposit,min_stake_provider,shares,
contributor, etc.) — correctly absent; not flagged per settled decision. trace/archiveaddon+extension router-config nuance documented in the probe report (per-combo
node-urlscoverage requirement) — explicitly called out by the probe author as a router-config
concern, not a spec defect. No spec change implied.
Summary
- Endpoints/directives reviewed: all 8 FTM250-local APIs (4 main + 4 trace), all 5
parse_directives, both verifications, thearchiveextension, plus the FTM4002 testnet
override and the ~50-method inherited ETH1 surface cross-checked against the probe's 62
method-probe rows. - Gaps by severity: 1 CRITICAL, 4 MEDIUM, 3 MINOR.
- Readiness: PR fix(spec): raise FTM250 average_block_time to 3000 ms (MAG-4589) #199's single-value change (1000 → 3000 ms) is directionally correct but does not
land on a value consistent with the live chain — Phase 8's empirical measurement (~6410 ms avg)
indicates the fix is incomplete. Recommend revisingaverage_block_timeto track the measured
value before merge, and recomputingallowed_block_lag_for_qos_syncto match. The MEDIUM/MINOR
items (trace determinism mismatch, dag_* methods, inherited-field duplication, FTM4002 staleness)
are pre-existing and not blocking for this specific PR, but are flagged for a follow-up pass.
|
Phase 10 — synthesize gaps + fix pass (+ Phase 10b smoke re-probe) Consolidation: 2 critical, 6 medium; 3 disable-suggestions stripped → Changes applied to the working tree (uncommitted; a workflow step commits these)
- "average_block_time": 3000,
- "allowed_block_lag_for_qos_sync": 10,
+ "average_block_time": 6260,
+ "allowed_block_lag_for_qos_sync": 2,Resulting state:
Auto-decisions at the STOP-and-ask gates (unattended run — conservative default taken, recorded)
Governance-field guard (smart-router #218)The fix pass introduced none of the 15 removed fields. Phase 10a — offline static gates re-run after the fixer
Phase 10b — smoke regression test:
|
| Probe | Phase 8 | Phase 10b | Verdict |
|---|---|---|---|
eth_blockNumber (GET_BLOCKNUM) |
PASS | PASS | no change |
eth_chainId (chain-id verification) |
PASS | PASS | no change |
dag_getEvent |
FAIL -32601 |
FAIL -32601 |
no change |
dag_getEventPayload |
FAIL -32601 |
FAIL -32601 |
no change |
dag_getHeads |
FAIL -32601 |
FAIL -32601 |
no change |
eth_accounts |
PASS | PASS | no change |
trace_block (addon) |
TESTED_OK | PASS | no change |
eth_getBalance + lava-extension: archive |
TESTED_OK | PASS | no change |
No regressions. Log-scan: 5 non-benign lines, all traced to 1rpc.io/ftm's plan usage limit (-32001) and the documented archive pairing-snapshot noise; per the rate-limit carve-out none downgraded a classification. No fatal/panic post-boot. Container torn down cleanly.
|
Phase 11 — final reviewer verdict: ✅ APPROVED
The final reviewer ran in clean context against
Honest scoping of this verdict
|
|
Phase 12 — closing summary checklist (tail of the Phase 11 span; this pipeline run covered Phases 8–11 only) Governance-field guard (smart-router #218) — final state
What is left in the working tree
Run stats — this pipeline run (Phases 8–11) onlyThese figures cover only Phases 8–11, run in this workflow run. They are not a 1–11 grand total: Phases 1–7 did not run here (this is a resumable entry on an already-open PR, and this PR amends an existing spec rather than creating one). The true end-to-end cost of the spec would be this run plus the run that produced the original spec — stating that rather than printing a number that looks complete. Retry commands, if you want any of this redone
If you want to keep |
|
📦 Committed pipeline fixes to |
What
fantom.json, FTM250:average_block_time1000 → 3000 ms. FTM4002 (testnet) is unchanged.Why
smartrouter_latest_blockon a PROD tenant).debugadd-on. 13% ofdebug_traceBlockByHashcalls gotNo Providers For Addon.The router-side fix is smart-router PR #570.
Not changed (review point)
allowed_block_lag_for_qos_syncstays at 10. The SOLANA change (MAG-4056) recomputed it asceil(10000 / average_block_time). Here that would give 4, which tightens how far behind a provider may be before QoS sync counts it as lagging. I left it at 10 because only the block time was requested. Say if you want it moved to 4.🤖 Generated with Claude Code