Skip to content

fix(spec): raise FTM250 average_block_time to 3000 ms (MAG-4589) - #199

Merged
Tomelia1999 merged 1 commit into
mainfrom
fix/ftm250-block-time
Oct 22, 2026
Merged

Tomelia1999 merged 1 commit into
mainfrom
fix/ftm250-block-time

Conversation

@Tomelia1999

@Tomelia1999 Tomelia1999 commented Oct 22, 2026 •

Copy link
Copy Markdown
Contributor

What

fantom.json, FTM250: average_block_time 1000 → 3000 ms. FTM4002 (testnet) is unchanged.

Why

  • The spec value is far from the real block rate. It says 1000 ms. Fantom mainnet produced one block every ~6.6 s over the last hour (2026-10-22, from smartrouter_latest_block on a PROD tenant).
  • The router derives its head-stall threshold from this value ("about 10 block times", MAG-3986). At 1000 ms, a provider one block behind for ~10 s is marked stalled and taken out of rotation.
  • On a PROD tenant that took out tatum, the only provider serving the debug add-on. 13% of debug_traceBlockByHash calls got No Providers For Addon.
  • 3000 ms triples the window before a one-block lag counts as a stall.

The router-side fix is smart-router PR #570.

Not changed (review point)

allowed_block_lag_for_qos_sync stays at 10. The SOLANA change (MAG-4056) recomputed it as ceil(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

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>
@magmadevs-bot

Copy link
Copy Markdown
Contributor

🤖 Spec pipeline started on PR open — running Phase 8 → 11. Results post here as comments. View run

@Tomelia1999
Tomelia1999 merged commit 89531c1 into main Oct 22, 2026
11 of 16 checks passed
@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 8 — smart-router boot + multi-node method probe

Resumable pipeline run (Phases 8–11), PR #199. Endpoints self-researched (no mainnet=/testnet= override supplied).

Verdict Value
PARSE: OK
VERIFY: OK
ADDONS: 2 tested-ok / 0 failed / 0 not-testable
Counts PASS=50 FAIL=9 SKIP=2 UNPROBED=0 WARN=1 TIMEOUT=0 LOG_WARN=0
TESTNET_VERIFY: SKIPPED (no live FTM4002 endpoint exists)
BLOCK_TIME: mainnet ~6260–6557 ms (5 samples / 3 upstreams / 2 windows) · testnet skipped
Teardown clean (no leftover containers)

⚠️ Headline finding — BLOCK_TIME_MISMATCH (mainnet)

Spec (as changed by this PR) = 3000 ms. Empirical = ~6410 ms average across 5 independent samples. Drift +108% … +119%, far past the 20% gate.
This corroborates the PR body's own ~6.6 s dashboard observation — so the direction of the change is right, but 3000 ms is still less than half the real block rate. A value in the ~6200–6600 ms range matches live mainnet.

⚠️ Second finding — FTM4002 declares its own average_block_time: 1000

The testnet entry does not inherit the mainnet value (it sets 1000 explicitly, untouched by this PR), so raising FTM250 alone leaves FTM4002 at 1000 ms. It could not be live-measured — no public FTM4002 endpoint answered.

Probe notes

  • 9 FAIL rows are all -32601 on deprecated/unimplemented Ethereum methods inherited from ETH1 (eth_compileLLL, eth_getCompilers, eth_protocolVersion, eth_sign, eth_signTransaction, eth_getWork) plus the three chain-specific dag_* methods. 1 WARN: eth_getProof (-32000, survived re-probe).
  • Per the skill's free-tier rule, probe errors alone are not grounds for disabling — these are watch-list items, not defects.
  • GET_BLOCK_BY_NUM was never exercised by this router build's tracker cycle, but the directive was independently confirmed by a passing eth_getBlockByNumber probe through the router (hash/number/timestamp decoded correctly).
  • Upstreams: https://rpcapi.fantom.network, https://fantom.drpc.org, https://1rpc.io/ftm, each paired with wss://rpcapi.fantom.network / wss://fantom.drpc.org (the spec declares SUBSCRIBE/UNSUBSCRIBE, so every provider needs a ws upstream).
Full probe report (docs/fantom/METHOD_PROBE_REPORT.md)

Method Probe Report — fantom

Generated: 2026-10-22T12:01:37Z
Router image: ghcr.io/magma-devs/smart-router:main (sha256:5eda2282227737a0bc66ea77686e62484df66c992fd152b5f16d23cd278e81c1)
Router config: /tmp/sr_fantom.yml
Spec variant: FTM250 (jsonrpc)
Upstreams probed: https://rpcapi.fantom.network (+wss://rpcapi.fantom.network), https://fantom.drpc.org (+wss://fantom.drpc.org), https://1rpc.io/ftm (+wss://fantom.drpc.org for its ws requirement)

Config note (addon/extension combo requires explicit per-combo node-urls entries)

FTM250 declares a subscribe-capable base collection AND an addon (trace) AND an extension (archive) together. The router's static-provider verification computes a per-provider required-key matrix = {none,archive} × {none,websocket} × {none,addon:trace}, and EACH provider's own node-urls set must cover the subset of that matrix it participates in, or the whole provider is excluded at boot ("missing extensions or addons in definitions"). A naive single node-urls entry carrying addons: [trace, archive] plus a wss:// entry also carrying addons: [trace, archive] left two combos uncovered (trace-without-archive, over both http and ws) and all 3 providers failed startup verification with all static providers failed verification. Fix: for upstream-1/2 (which genuinely serve trace+archive), add a second https:// node-urls entry with addons: [trace] only (no archive) so the provider's own supported-set covers the missing key, and keep the wss:// entries addon-free (archive/trace are never requested over the ws transport in this spec, so the ws entry only needs to cover the plain/websocket-bare keys). This is a router-config nuance, not a spec defect — flagging for anyone re-running this phase on another addon+extension+subscription chain.

Final working direct-rpc shape used:

  - name: "fantom-upstream-1"
    node-urls:
      - url: "https://rpcapi.fantom.network"
        addons: [trace, archive]
      - url: "https://rpcapi.fantom.network"
        addons: [trace]
      - url: "wss://rpcapi.fantom.network"
  - name: "fantom-upstream-2"
    node-urls:
      - url: "https://fantom.drpc.org"
        addons: [trace, archive]
      - url: "https://fantom.drpc.org"
        addons: [trace]
      - url: "wss://fantom.drpc.org"
  - name: "fantom-upstream-3"
    node-urls:
      - url: "https://1rpc.io/ftm"
        addons: [archive]
      - url: "wss://fantom.drpc.org"

All 3 providers validated successfully with this shape; router served eth_chainId → 0xfa within seconds of boot.

Parse-directive & verification runtime check (Step 3.5)

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 failure
  • https://xapi.testnet.fantom.network/lachesis — no response
  • https://fantom-testnet-rpc.publicnode.com — HTTP 404
  • https://fantom-testnet.drpc.org — {"error":{"message":"Unknown network","code":11}}
  • https://endpoints.omniatech.io/v1/fantom/testnet/public — HTTP 521
  • https://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.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 9 — parallel reviewers (3 independent /review-spec passes)

Reviewer TALLY Report
1 CRITICAL=2 MEDIUM=2 MINOR=1 docs/fantom/SPEC_REVIEW_GAPS_parallel_1.md
2 CRITICAL=1 MEDIUM=6 MINOR=3 docs/fantom/SPEC_REVIEW_GAPS_parallel_2.md
3 CRITICAL=1 MEDIUM=4 MINOR=3 docs/fantom/SPEC_REVIEW_GAPS_parallel_3.md

All three reports are distinct files with distinct digests (no shared-path overwrite). No finding cited a line number beyond fantom.json's 316 lines, so none reviewed stale state.

Merged gaps

Unanimous CRITICAL — 3/3 reviewers

  • average_block_time: 3000 (FTM250) is still ~2.1× below the live chain. Phase 8 measured 6260 / 6260 / 6410 / 6557 / 6557 ms across 3 upstreams and 2 window sizes (avg ~6410 ms). Every sample trips the >20% rule. Reviewer 2's phrasing: the PR "appears to have split the difference between the stale 1000 ms and the true ~6600 ms". The direction of the change is right; the magnitude is not.

Raised by 3/3, severity split

  • allowed_block_lag_for_qos_sync: 10 was not recomputed (R1 CRITICAL, R2 MEDIUM, R3 MEDIUM). The skill formula is max(ceil(10000 / average_block_time), 1); 10 is exactly right for the old 1000 ms and wrong for any new value — 4 at 3000 ms, 2 at the empirical ~6400 ms. This is the open question the PR body itself raises, so the PR currently merges a spec that is internally inconsistent with its own block time.

MEDIUM / MINOR — pre-existing, outside this PR's one-line diff

  • FTM4002 declares its own average_block_time: 1000 (it does not inherit FTM250's), independently stale and unverifiable — no public FTM4002 endpoint answered (R1 MEDIUM, R2 MEDIUM, R3 MINOR/informational).
  • trace_block / trace_transaction / trace_get override deterministic away from the ETH1 baseline with no stated reason (R1 MEDIUM, R3 MEDIUM, R2 MINOR).
  • dag_getEvent / dag_getEventPayload use EMPTY block-parsing where the spec's own precedent for hash-keyed lookups is DEFAULT; dag_getHeads uses DEFAULT despite taking an explicit epoch argument (R1 MINOR, R2 MEDIUM ×2).
  • dag_* ×3 and eth_getProof are enabled: true but absent from the live RPC surface on all 3 upstreams (R3 MEDIUM, R2 MEDIUM). Probe-only evidence — per the skill's free-tier rule these are watch-list items, not grounds for disabling.
  • Fantom's native abft_* namespace is absent from the spec (R2 MEDIUM).
  • The debug add-on — the operational motivation for this PR — is not declared on FTM250 at all, so the probe could not exercise it (R2 MINOR).
  • Redundant byte-for-byte re-declaration of fields already inherited from ETH1 (R3 MINOR).
Reviewer 1 — full report

Spec Review Gap Report — fantom.json (Reviewer 1)

Reviewed: fantom.json (FTM250 mainnet, FTM4002 testnet)
API docs: none provided (no OpenAPI/API doc diff possible — API completeness audit limited to
cross-referencing the live probe results in docs/fantom/METHOD_PROBE_REPORT.md and the inherited
ETH1 parent spec)
Credentials: none provided (no live Phase 9 testing performed by this reviewer; relying on the
pre-existing empirical measurements in docs/fantom/METHOD_PROBE_REPORT.md, generated 2026-10-22)

Context

This is an update PR (branch fix/ftm250-block-time, PR #199) that changes exactly one value in
fantom.json: FTM250 average_block_time 1000 → 3000 ms (MAG-4589), to stop the router's
head-stall detector from evicting a provider that was merely one block behind. Per
docs/fantom/METHOD_PROBE_REPORT.md Phase 0 (removed-field guard): PASS, no removed fields.
The canonical { "proposal": { "specs": [...] } } envelope is used correctly; blocks_in_finalization_proof: 1
on both entries is correct for Fantom/Opera's aBFT near-instant finality and is not flagged.

Findings

CRITICAL-1: average_block_time (FTM250) is still off by >100% from the empirically measured value

  • File/line: fantom.json:13 — "average_block_time": 3000

  • Evidence: docs/fantom/METHOD_PROBE_REPORT.md Step 8 ("Empirical block time") measured Fantom
    mainnet across 3 independent upstreams (rpcapi.fantom.network, fantom.drpc.org, 1rpc.io/ftm)
    and 2 window sizes (100 blocks, 1000 blocks), using the eth_blockNumber + eth_getBlockByNumber
    timestamp-delta recipe. All 5 samples cluster tightly at 6260–6557 ms, averaging ~6410 ms:

    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: 10 is exactly 10000 / 1000 — i.e., it was computed for the
    old average_block_time of 1000 ms and was left unchanged when this PR bumped
    average_block_time to 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 ("should allowed_block_lag_for_qos_sync be 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 while average_block_time triples
    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_sync together with whichever
    average_block_time value is finally chosen — ceil(10000 / average_block_time), minimum 1 (e.g.
    ≈4 if average_block_time stays at 3000; ≈2 if corrected to ~6400–6600 per CRITICAL-1). Do not
    ship this PR with average_block_time changed and allowed_block_lag_for_qos_sync left 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 imports FTM250 at
    fantom.json:284 but 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.network no
    response, xapi.testnet.fantom.network/lachesis no response, fantom-testnet-rpc.publicnode.com
    404, fantom-testnet.drpc.org "Unknown network", endpoints.omniatech.io HTTP 521,
    rpc.ankr.com/fantom_testnet HTTP 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": true with 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); only trace_filter (line ~208) keeps deterministic: false.
  • Evidence: ETH1's own trace add-on collection (ethereum.json) defines
    trace_block, trace_get, trace_transaction, and trace_filter all with
    category.deterministic: false. Because FTM250 imports ETH1 and re-defines these same API
    names inside its own add_on: "trace" collection, merge semantics (spec guide Step 3.1a: "APIs —
    differentiator Name — child version wins") mean FTM250's deterministic: true overrides
    ETH1's false for three of the four trace methods, with no comment explaining the divergence.
  • Impact: deterministic: true enables 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: false for trace_block/trace_transaction/trace_get rather 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_getEventPayload and dag_getEvent, both
    "block_parsing": {"parser_arg": [""], "parser_func": "EMPTY"}
  • Evidence: Per the spec guide, EMPTY is 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 as eth_getTransactionByHash / eth_getBlockByHash, which the
    imported ETH1 parent spec configures as DEFAULT with parser_arg: ["latest"] (confirmed in
    ethereum.json), not EMPTY, 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.md method-probe results classify
    all three dag_* methods (dag_getEvent, dag_getEventPayload, dag_getHeads) as FAIL -32601,
    "method does not exist on this chain's current (Sonic-era) RPC surface." Per the reviewer's
    instructions, a probe-only -32601 is 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, the block_parsing should probably match the hash-lookup
    convention (DEFAULT/latest) rather than EMPTY, 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/when dag_* methods are confirmed reachable again.

Not flagged (settled / explicitly out of scope)

  • Absence of title/description/deposit and the nine removed governance fields — correct, per
    current model (settled decision a).
  • blocks_in_finalization_proof: 1 on both FTM250 and FTM4002 — correct for Fantom/Opera's aBFT
    near-instant finality (settled decision b).
  • block_distance_for_finalized_data: 0 on 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 pair block_distance_for_finalized_data: 0 with
    blocks_in_finalization_proof: 1); not a defect.
  • dag_getEvent, dag_getEventPayload, dag_getHeads, and eth_getProof/eth_getWork/etc.
    FAIL/WARN probe 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_FIELD hits in fantom.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_getBlockByNumber PASSED through the router with a
    correctly-decoded block).
  • Chain-id verifications — 0xfa (FTM250, = 250 decimal) and 0xfa2 (FTM4002, = 4002 decimal) are
    both correct and, for FTM250, confirmed live by the probe report (3/3 providers matched).
  • Pruning verification / archive extension (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) + 4 trace-addon APIs (trace_block, trace_filter,
    trace_transaction, trace_get) defined directly in fantom.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_time off of the
    unconditionally-wrong 1000ms) is directionally correct but the new value (3000ms) is itself still

    100% off the empirically measured live chain (~6410ms average), and the directly-dependent
    allowed_block_lag_for_qos_sync parameter 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.md Step 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 own BLOCK_TIME_MISMATCH rule
    (>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_time being 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
    only debug-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 single debug-addon provider on a cluster) remains
    very plausible at 3000 ms.
  • Fix: Set average_block_time to 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.json at average_block_time: 6500 all use
    allowed_block_lag_for_qos_sync: 2 (ceil(10000/6500)=2); akash.json at 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 changed average_block_time to 3000
    but left allowed_block_lag_for_qos_sync at 10, which no longer matches the formula
    (ceil(10000/3000)=4), and would be 2 at the empirically-correct ~6500 ms (CRITICAL-1 above).
  • Impact: allowed_block_lag_for_qos_sync is the QoS freshness tolerance — leaving it at 10
    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_sync alongside average_block_time (→ 2 if
    average_block_time is corrected to ~6500 ms per CRITICAL-1; 4 if kept at 3000).

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_getHeads takes one parameter —
    a HEX-encoded epoch number, or the strings "latest"/"pending" — at params position 0. This
    is structurally identical to eth_getBlockByNumber's block-number argument, which the spec
    (and ETH1) correctly parses with PARSE_BY_ARG, parser_arg: ["0"] (fantom.json:96,
    ethereum.json). dag_getHeads instead uses DEFAULT, which always tags the request as
    "latest" regardless of what epoch the caller actually passed.
  • Impact: A consumer calling dag_getHeads for 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-69 and fantom.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 as eth_getTransactionByHash, eth_getBlockByHash, and
    eth_getTransactionReceipt. ETH1 (inherited by this spec) classifies all three of those as
    DEFAULT / parser_arg: ["latest"], not EMPTY — 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 via EMPTY. dag_getEvent /
    dag_getEventPayload break that precedent.
  • Impact: Tagging these as EMPTY means 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_getTransactionByHash case.
  • Fix: Align with the eth_getTransactionByHash/eth_getBlockByHash precedent:
    {"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's add_on: "" collection (fantom.json:16-182); eth_getProof is inherited unmodified
    from ethereum.json's main collection.
  • Evidence: docs/fantom/METHOD_PROBE_REPORT.md classifies eth_getProof as 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 supports eth_getProof for the Fantom chain."
  • Impact: Every provider serving FTM250 inherits eth_getProof as 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, per SPEC_GUIDE.md Step 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
    explicit 1000 (imports only bring inherited API collections/parse directives/verifications
    per the merge rules in SPEC_GUIDE.md Step 3.1a; top-level scalar fields like
    average_block_time are not inherited at all and must be set per-spec). This value was never
    touched by this PR and pre-dates it. Per docs/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 (only ftm_currentEpoch
    and the three dag_* 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-included ftm_*/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 inherited trace collection 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 to true (only trace_filter is left
    false, matching ETH1). Arguably true is 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
    false for 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_getEvent explicitly returns the event without
    transactions, while dag_getEventPayload returns the event with full transaction data (or
    just hashes, depending on a boolean flag) — i.e. dag_getEventPayload is strictly the heavier
    of the two calls, analogous to how eth_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, leaving dag_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.md method-probe table covers only the main collection, plus
    trace/archive; FTM250's debug collection (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 only debug-addon provider on a cluster" — i.e. the debug add-on is in active production
    use on Fantom. No empirical evidence in this review pass confirms the inherited ETH1 debug
    collection actually works against a live Fantom (Sonic) node.
  • Impact: None to the spec itself (ETH1's debug collection is inherited automatically per
    the spec's own correct omission of a debug override, which is the right pattern per
    SPEC_GUIDE.md Step 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 debug add-on given its
    direct relevance to the bug this PR fixes.

Summary

  • Endpoints/parameters reviewed: both api_collections in 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/inherited pruning; the archive extension; all 4 parse directives
    (GET_BLOCKNUM/GET_BLOCK_BY_NUM/GET_EARLIEST_BLOCK/SUBSCRIBE/UNSUBSCRIBE); cross-
    checked against docs/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
    by average_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_time should be moved into the empirically measured range and
    allowed_block_lag_for_qos_sync recalculated 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_NUM directive correctness: the probe's Step 3.5 notes the router's automatic
    tracker cycle never issued a block_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_getBlockByNumber method 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_NUM function_template/result_parsing (PARSE_CANONICAL, parser_arg: ["0","hash"],
    encoding: hex) is correct. No action needed on fantom.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 / archive 0x0), 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 the trace addon).
  • block_distance_for_finalized_data: 0 and blocks_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: 0 with blocks_in_finalization_proof: 1 for 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/archive addon+extension router-config nuance documented in the probe report (per-combo
    node-urls coverage 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, the archive extension, 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 revising average_block_time to track the measured
    value before merge, and recomputing allowed_block_lag_for_qos_sync to 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.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 10 — synthesize gaps + fix pass (+ Phase 10b smoke re-probe)

Consolidation: 2 critical, 6 medium; 3 disable-suggestions stripped → docs/fantom/FIX_LIST.md.

Changes applied to the working tree (uncommitted; a workflow step commits these)

File:line Change Gap
fantom.json:13 FTM250 average_block_time 3000 → 6260 CRITICAL, unanimous R1/R2/R3
fantom.json:14 FTM250 allowed_block_lag_for_qos_sync 10 → 2 CRITICAL (R1) / MEDIUM (R2, R3)
-                "average_block_time": 3000,
-                "allowed_block_lag_for_qos_sync": 10,
+                "average_block_time": 6260,
+                "allowed_block_lag_for_qos_sync": 2,

Resulting state: FTM250 abt=6260 lag=2 bdff=0 bifp=1 · FTM4002 abt=1000 lag=10 bdff=0 bifp=1 (testnet untouched).

Note for the author: this changes the value your PR proposed. 6260 is the lowest of Phase 8's five empirical samples (6260 / 6260 / 6410 / 6557 / 6557 ms), picked under the skill's "never round up" tie-breaker — it is the most conservative value consistent with the live chain, and still more than doubles the stall window relative to your 3000. lag follows mechanically from max(ceil(10000 / average_block_time), 1); leaving it at 10 would have shipped a spec inconsistent with its own block time. Both are revertible if you disagree — see D1/D2 below.

Auto-decisions at the STOP-and-ask gates (unattended run — conservative default taken, recorded)

# Gate Decision
D1 which block-time value 6260 ms — lowest of 5 empirical samples; "never round up" rule (Phase 4 tie-breaker)
D2 recompute allowed_block_lag_for_qos_sync? Yes → 2. The PR body raised this as an open question; the spec guide states it is derived, not a free parameter
D3 blocks_in_finalization_proof / block_distance_for_finalized_data unchanged (1 / 0) — Fantom Opera is aBFT, instant finality
D4 FTM4002's own stale average_block_time: 1000 unchanged — no live FTM4002 endpoint exists to verify against, and 1000/10 is internally consistent. Changing an unverifiable value would be drift. Report-only.
D5 pre-existing MEDIUM/MINOR gaps outside the one-line diff report-only — a block-time PR is not widened with unrelated edits (trace deterministic, dag_* block_parsing, missing abft_*, absent debug add-on, eth_getProof, CU nits)
D6 disable suggestions for dag_* ×3 and eth_getProof stripped to watch-list — probe-only evidence (-32601) never justifies disabling. Needs a paid/dedicated node to re-test.

Governance-field guard (smart-router #218)

The fix pass introduced none of the 15 removed fields. check_unused_fields.sh → RESULT: PASS (no removed fields). The spec remains the canonical envelope { "proposal": { "specs": [ … ] } }; compute_units untouched; no category.subscription anywhere — subscriptions are expressed solely by the SUBSCRIBE/UNSUBSCRIBE parse directives.

Phase 10a — offline static gates re-run after the fixer

Gate Result
jq . exit 0
check_method_schema.sh PASS (8 rows), no FAIL
check_unused_fields.sh PASS
check_hanging_api.sh --base origin/main PASS, no FAIL, no INFO
check_stateful.sh --base origin/main PASS, no FAIL, no INFO
check_disabled_count.sh 0 distinct disabled methods → <!-- disabled-count: 0 -->; Disabled-API Justifications ledger is empty (nothing is disabled)

Phase 10b — smoke regression test: SMOKE: OK

Re-booted the router against the fixed spec. PARSE: OK (smartrouter_latest_block climbing 123783155→123783366, no parse-signature lines; GET_BLOCK_BY_NUM again NOT_EXERCISED by this build's tracker cycle — same router behaviour as Phase 8, not a regression). VERIFY: OK (chain-id 5/5 = 0xfa, pruning 9/9, trace 2/2). ADDONS: 2 tested-ok / 0 failed / 0 not-testable (trace addon and archive extension both PASS).

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.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 11 — final reviewer verdict: ✅ APPROVED

TALLY: CRITICAL=0 MEDIUM=0 MINOR=0 on the fixed spec.

The final reviewer ran in clean context against fantom.json as it now stands in the working tree, and confirmed:

  • average_block_time: 6260 — correct. Matches the lowest of Phase 8's five empirical samples; resolves the CRITICAL BLOCK_TIME_MISMATCH all three Phase-9 reviewers raised against 3000.
  • allowed_block_lag_for_qos_sync: 2 — correct. max(ceil(10000/6260), 1) = 2. The prior 10 was stale from the original 1000 ms baseline and had never been recomputed across either block-time edit.
  • Consistent with the untouched finality fields blocks_in_finalization_proof: 1 / block_distance_for_finalized_data: 0 (aBFT, near-instant finality — governed by the finality-typed rule, not the block-time fallback).
  • No adjacent regression. The diff is exactly two lines, both on FTM250; FTM4002 and every collection, API, parse directive, verification, header and extension are byte-identical to the pre-fix state. jq valid, canonical envelope, no duplicate API names, inheritance chain (FTM4002 → FTM250 → ETH1) intact.
  • Disabled-API ledger trivially satisfied — zero enabled: false APIs and zero disabled collections, so nothing requires justification.

Honest scoping of this verdict

APPROVED covers the question this PR asks — is FTM250's block time, and the parameter derived from it, now right. The reviewer was explicitly instructed not to count the pre-existing gaps listed under REPORT-ONLY / WATCH-LIST in docs/fantom/FIX_LIST.md toward its tally, because fixing them would widen a deliberately narrow PR (decisions D4–D6 in the Phase 10 comment). Those gaps remain open, and are worth separate tickets:

  • trace_block / trace_transaction / trace_get set deterministic: true where ETH1 sets false, with no stated reason.
  • eth_getProof is inherited from ETH1 but the Sonic-era node client no longer serves it for Fantom (reviewer 2 cited a URL-backed source — this is positive evidence, not probe-only, so it is genuinely actionable).
  • dag_getEvent / dag_getEventPayload use EMPTY block-parsing against the spec's own DEFAULT precedent; dag_getHeads uses DEFAULT despite taking an epoch argument. All three also return -32601 on every probed upstream (probe-only evidence — not grounds for disabling).
  • Fantom's native abft_* namespace is entirely absent from the spec.
  • The debug add-on — the operational trigger for this PR — is not declared on FTM250 at all, so nothing in this pipeline could exercise it.
  • FTM4002 carries its own stale, unverifiable average_block_time: 1000; no public FTM4002 endpoint answered, so TESTNET_VERIFY is SKIPPED for this PR. The testnet entry ships with no live verification.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 12 — closing summary checklist (tail of the Phase 11 span; this pipeline run covered Phases 8–11 only)

#### File Validation
- ✓ JSON syntax valid                                    (Phase 10a `jq` exit 0; re-confirmed by the Phase 11 reviewer)
- ✓ All required fields present                          (Phase 11 structural sweep; `check_unused_fields.sh` PASS)
- ✓ No duplicate API names within any collection         (Phase 11 full-file check)
- ✓ Proper indentation/formatting                        (surgical 2-line sed edit; 4-space indent and no-trailing-newline convention preserved)

#### Configuration Verification
- ✓ Network parameters calculated per formulas           (Phase 10 fix: abt=6260 from 5 empirical samples; lag=max(ceil(10000/6260),1)=2; bifp=1/bdff=0 finality-typed for aBFT)
- ~ All APIs tested and working                          (Phase 8 probe: PASS=50 FAIL=9 SKIP=2 UNPROBED=0 WARN=1 TIMEOUT=0 — see docs/fantom/METHOD_PROBE_REPORT.md; 2 stateful methods skipped; the 9 FAILs are -32601 on deprecated ETH1-inherited + dag_* methods, watch-listed not disabled)
- ~ Block parsing validated for each API                 (Phase 8 existence-tested through the router; full per-API parse validation needs production traffic)
- ✓ Parse directives executed by live router             (Phase 8 Step 3.5: PARSE=OK, VERIFY=OK; Phase 10b re-check: PARSE=OK, VERIFY=OK. GET_BLOCK_BY_NUM was NOT_EXERCISED by this router build's tracker cycle in both passes — independently confirmed via a passing eth_getBlockByNumber probe)
- ~ Addons & extensions tested                           (Phase 8 Step 1c: 2 tested-ok / 0 failed / 0 not-testable — `trace` addon, `archive` extension; both re-confirmed PASS in Phase 10b. NOTE: the `debug` add-on that motivated this PR is not declared in the spec, so nothing could test it)
- ✓ Verifications pass on live nodes                     (Phase 8 boot-window scan: chain-id 3/3, pruning 3/3, trace 2/2; Phase 10b: chain-id 5/5 = 0xfa, pruning 9/9, trace 2/2)
- ☐ Compute units benchmarked under expected load        (user to measure — untouched by this PR)

#### Documentation (out of skill scope — manual reminder)
- ☐ SPEC_IMPLEMENTATION.md created
- ☐ API_REFERENCE.md created
- ☐ TESTING_GUIDE.md created
- ☐ QUICK_START.md created

#### Testnet vs Mainnet
- ✓ Mainnet spec complete                                (FTM250 pre-existing and unchanged apart from the 2 fixed network params)
- ✓ Testnet spec inherits correctly                      (FTM4002 imports FTM250; Phase 11 confirmed the chain intact. It overrides average_block_time itself — 1000 ms — so it does NOT pick up the mainnet fix)
- ~ Chain IDs verified for mainnet AND testnet           (mainnet 0xfa live-verified in Phase 8 boot + Phase 10b; testnet 0xfa2 NOT live-verified — no endpoint)
- ☐ Both tested on respective networks                   (TESTNET_VERIFY: SKIPPED — all six public FTM4002 endpoints dead / wrong-network / key-gated; the network appears decommissioned post-Sonic. The testnet entry ships with no live verification)

#### Governance Prep (out of skill scope — manual reminder)
- ☐ Proposal JSON formatted correctly                    (canonical `{ "proposal": { "specs": [ … ] } }` envelope; no title/description/deposit, none of the 15 removed fields — `check_unused_fields.sh` PASS)
- ☐ Community feedback gathered (if applicable)

Governance-field guard (smart-router #218) — final state

check_unused_fields.sh fantom.json → RESULT: PASS (no removed fields). The fix pass introduced none of the 15 removed fields: no spec-level governance fields, no proposal.title/description, no top-level deposit, no extra_compute_units/category.local/category.subscription. compute_units remains the only compute-unit input and was not touched. Subscriptions are expressed solely by the SUBSCRIBE/UNSUBSCRIBE parse directives — there is no category.subscription anywhere in the file. <!-- disabled-count: 0 -->

What is left in the working tree

fantom.json is modified and uncommitted — 2 lines, both on FTM250 (average_block_time 3000→6260, allowed_block_lag_for_qos_sync 10→2). No git command was run by this pipeline run; the workflow step after it commits and pushes this edit to fix/ftm250-block-time.

Run stats — this pipeline run (Phases 8–11) only

Elapsed:         00h 41m 12s  (first→last logged activity)
Transcripts:     1 main + 8 subagent
API round-trips: 473  (main=76, subagents=397)

Fresh tokens:    input=946  output=265906  (sum=266852)
Cached tokens:   cache_read=31693907  cache_write=1418357
Total billed:    33379116 tokens

Split (total billed):  main=7374392  subagents=26004724

Models used:
  claude-sonnet-5         397 calls   26004724 billed
  claude-opus-5            77 calls    7517718 billed

These 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

Want Command
Re-probe only (e.g. with your own node) /rerun-probe or /rerun-probe mainnet=https://your-node/rpc
Re-run the reviewers only /rerun-review
Re-run the fix pass only /rerun-fix
Re-run the final verdict only /rerun-final
Re-run a phase through to the end /rerun-from 8 (or 9/10/11)

If you want to keep average_block_time: 3000 or set allowed_block_lag_for_qos_sync back to 10, say so and revert those two lines — decisions D1/D2 in the Phase 10 comment were the unattended-run conservative defaults, not a mandate.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

📦 Committed pipeline fixes to fix/ftm250-block-time (ea244fe): fantom.json — the branch now matches the spec that Phase 10b/11 verified.

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

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants