Networks

How it works

Architecture concept. NetworkArchitecture is a string enum with two valid values: "evm" and "svm" (common/network.go:L14-17). The canonical id is evm:<chainId> from util.EvmNetworkId, or svm:<cluster> / svm:<chain>:<cluster> from util.SvmNetworkId (util/ids.go:L1-30). The network Prometheus label equals the alias when set, otherwise the raw id.

architecture is inferred when omitted: a network carrying an svm block derives architecture: svm, one carrying evm (or neither) derives evm (common/defaults.go:L2010-2028). Declaring architecture: svm auto-creates an empty svm block, and networkDefaults.evm is never injected into an SVM network. See SvmNetworkConfig below and the SVM reference pages.

Lazy creation. NetworksRegistry.GetNetwork fast-paths a sync.Map lookup; on miss it validates the id format and schedules a bootstrap task. The task: (1) resolves or synthesizes a NetworkConfig and runs SetDefaults so it inherits networkDefaults exactly like static networks; (2) calls PrepareUpstreamsForNetwork — fans out to every configured provider, polls 200 ms for up to 30 s until ≥1 upstream is ready; (3) wires the cache DAL; (4) registers with the selection-policy engine. Statically-declared networks bootstrap in background at startup through the same machinery; a failed eager bootstrap is retried when the first request arrives.

Forward pipeline order (exact sequence, erpc/networks.go:L931-1603):

1. Apply directiveDefaults + start OTel span.
2. Static response match — returns immediately if hit (before multiplexer, cache, upstreams).
3. Multiplexer — leader/follower on CacheHash; followers copy the leader's response.
4. Cache read — non-null hit closes the mux and returns.
5. Policy-engine upstream ordering — falls back to registration order if empty; ErrNoUpstreamsFound (404) if still empty.
6. EVM pre-forward hook (future-block short-circuit; never cached).
7. Stateful-method guard, network rate-limit, request normalization.
8. Failsafe executor selection — first config-order entry matching method + finality.
9. Upstream sweep — per-upstream block-availability gate, hedge/retry orchestration.
10. Post-sweep: timeout translation, last-valid-response fallback, async cache set, misbehavior accounting.

networkDefaults inheritance (common/defaults.go:L1781-1973). "Network wins; defaults fill gaps." Scalars inherit when zero-valued; pointers when nil. selectionPolicy and directiveDefaults are whole-struct copies (no per-field merge). evm is a whole-struct copy when absent from the network, otherwise per-field fill for 14 named fields. Failsafe: if the network has entries, each is matched against the first compatible default (wildcard method + finality) and missing sub-fields are inherited; if the network has no entries the defaults list is deep-copied wholesale.

Finality classification (erpc/networks.go:L1645-1743). Explicit finalized/realtime flags in methods.definitions win. Otherwise the block ref/number is extracted from the request, then from the response body (for hash-keyed cache hits). Non-numeric tags → realtime; numeric blocks are checked via EvmIsBlockFinalized on the serving upstream, then the last upstream tried, then the network-wide lowest-finalized heuristic.

Served tip. Default ("max mode"): EvmHighestLatestBlockNumber / EvmHighestFinalizedBlockNumber return the MAX across policy-eligible, non-syncing upstreams. Setting evm.servedTip.enabledFor switches that axis to a cluster-min, cross-pod monotonic counter. Rollback tolerance is 1024 blocks (DefaultToleratedBlockHeadRollback, architecture/evm/evm_state_poller.go:L27 (opens in a new tab)). A use-upstream selector produces a per-group scoped tip keyed by the SHA-256 (first 8 bytes, hex-encoded) of the sorted matched upstream-id set; unmatched selectors compute a stateless min and emit no gauges. Group partitions are capped at 16 (maxServedTipPartitions); a "simple" group selector must be ≤128 chars, no whitespace, at most one leading !, and the matched set must be ≥2 upstreams and less than all upstreams. Syncing upstreams are excluded from every head computation (max mode, cluster mode, lowest-finalized, and guaranteed-method floors). EvmLeaderUpstream returns the upstream with the highest raw LatestBlock(); EvmLowestFinalizedBlockNumber returns the min positive effective finalized across non-syncing upstreams.

Config schema

projects[].networks[] — NetworkConfig

projects[].networks[].evm — EvmNetworkConfig

projects[].networks[].svm — SvmNetworkConfig

Not present on SvmNetworkConfig: there is no maxSlotsPerSignaturesQuery. An early design proposed one as an analogue of EVM's getLogs range cap, but getSignaturesForAddress is bounded by signature cursors (before/until), not by a slot range, so the key described semantics Solana does not have and was removed. minContextSlot is a node-freshness floor — the minimum bank slot at which a request may be evaluated — not a lower bound on returned history, so it cannot serve as a range cap either.

Cluster and genesis-hash validation. Known (chain, cluster) pairs — currently Solana mainnet-beta, devnet, and testnet — have their genesis hash validated at bootstrap by a single getGenesisHash call compared against a hardcoded table. Both a mismatch and a fetch failure fail the upstream, so a node mis-pointed at the wrong cluster never joins the pool. For unknown clusters (forks, private clusters) the same check runs only when the upstream sets svm.checkGenesisHash: true. getGenesisHash itself is then answered from the table with no upstream round-trip, mirroring EVM's eth_chainId short-circuit.

projects[].networks[].directiveDefaults — DirectiveDefaultsConfig

Data-integrity validation is configured under networks[].integrity (not directiveDefaults) — an opt-in level/checks/profiles block. The deprecated per-check flags (validateLogsBloomMatch, enforceLogIndexStrictIncrements, validateTransactionsRoot, …) are translated into it at startup. See Integrity checks.

projects[].networkDefaults — NetworkDefaults

Note: networkDefaults has no alias, methods, staticResponses, or architecture fields — those are per-network only.

server.aliasing.rules[] — domain-based aliasing

Worked examples

All patterns below are distilled from real production fleets; comments explain the non-obvious choices.

1. The production baseline: networkDefaults with finality-split failsafe policies. Block-availability races on realtime/unfinalized requests need a non-zero retry delay; finalized/unknown don't — this is why production splits them:

projects:  - id: main    networkDefaults:      # All chains inherit these unless they set their own failsafe list      directiveDefaults:        retryEmpty: true        retryPending: false      # multiplexing: false in production to avoid follower-timeout amplification      # on chains where every block is a write (e.g. high-throughput L2s)      multiplexing: false      evm:        getLogsMaxAllowedRange: 30000        getLogsSplitOnError: true        # cluster-min tip on "latest" prevents backward tip jumps across pods        servedTip:          enabledFor: [latest]      failsafe:        # NOTE: delay MUST NOT be 0 for realtime/unfinalized — a short non-zero        # delay gives shared-state propagation time to catch up after a block        # arrives on one upstream but not yet on another        - matchMethod: "eth_call|eth_getLogs"          matchFinality: [realtime, unfinalized]          hedge:            quantile: 0.95            maxCount: 1            minDelay: 500ms            maxDelay: 10s          retry:            maxAttempts: 4            delay: 50ms        - matchMethod: "eth_call|eth_getLogs"          matchFinality: [finalized, unknown]          hedge:            quantile: 0.95            maxCount: 1            minDelay: 500ms            maxDelay: 10s          retry:            maxAttempts: 4            delay: 0        - matchMethod: "*"          retry:            maxAttempts: 6            delay: 50ms    networks:      - architecture: evm        evm: { chainId: 1 }        alias: ethereum      - architecture: evm        evm: { chainId: 42161 }        alias: arbitrum

2. Per-chain bespoke policy appended before the shared catch-all. Ethereum mainnet adds consensus on eth_getLogs and state-read integrity checks; Arbitrum bumps the getLogs hedge floor for its faster blocks. Both spread sharedNetworkFailsafe at the end so the catch-all policy is never per-chain:

networks:  - evm: { chainId: 1 }    alias: ethereum    failsafe:      # Ethereum-specific: 2-of-3 consensus on getLogs for indexing integrity      - matchMethod: "eth_getLogs|eth_getBlockReceipts"        matchFinality: [unfinalized, unknown]        timeout: { duration: 15s }        hedge:          quantile: 0.95          maxCount: 1          minDelay: 500ms          maxDelay: 10s        retry:          maxAttempts: 6          delay: 0          emptyResultDelay: 1000ms        # consensus config would follow here      # ... sharedNetworkFailsafe spread after (catch-all always last)
  - evm: { chainId: 42161 }    alias: arbitrum-one    failsafe:      # Arbitrum-specific: getLogs minDelay raised to 1000ms — Arbitrum delivers      # blocks at ~250ms and block-availability races persist slightly longer      - matchMethod: "eth_getLogs|eth_getBlockReceipts"        matchFinality: [unfinalized]        hedge:          quantile: 0.95          maxCount: 1          minDelay: 1000ms          maxDelay: 10s        retry:          maxAttempts: 6          delay: 0      # ... sharedNetworkFailsafe spread after

3. Static genesis-block response for a chain that starts at block 1. Serve a canned reply before the multiplexer and cache so clients don't hit a dead upstream on block 0. The staticResponses array is checked before everything else in the forward pipeline:

networks:  - evm: { chainId: 1328 }    alias: sei-testnet    staticResponses:      - method: eth_getBlockByNumber        params: ["0x0", false]        response:          result:            # Fill the fields your clients read; unrecognised fields are fine            number: "0x0"            hash: "0x0000000000000000000000000000000000000000000000000000000000000000"            parentHash: "0x0000000000000000000000000000000000000000000000000000000000000000"            transactions: []

4. Skip data-integrity validation for non-standard chains. ZkSync Era and other ZK-rollups use a non-standard transactionsRoot (and other encodings) the data-integrity module's recompute checks can't model. The module is opt-in, but if you enabled it project-wide, turn it off for that chain — a network integrity block overrides the project one:

networks:  - evm: { chainId: 324 }    alias: zksync-mainnet    # Override the project-wide integrity level to off for this chain    # (or disable just the transactionsRoot checks via integrity.checks).    integrity:      level: off

5. Domain-based aliasing for fully path-free routing. Route an entire subdomain straight to a chain — no project or network segment in the URL path. The alias and domain rule work together so clients call a clean HTTPS endpoint:

server:
  aliasing:
    rules:
      - matchDomain: "eth.rpc.example.com"
        serveProject: main
        serveArchitecture: evm
        serveChain: "1"
      # Wildcard: any unknown subdomain falls through to the main project
      - matchDomain: "*.rpc.example.com"
        serveProject: main

POST https://eth.rpc.example.com/   →  main/evm:1

6. Multiple SVM chains side by side. chain defaults to solana, so a plain Solana cluster keeps the short two-segment id. Naming a fork's chain switches the id to three segments, which is what keeps cache partitions and alias registration from colliding between svm:mainnet-beta and svm:fogo:mainnet. Note that cluster stays per-network — it is identity, so networkDefaults.svm carries only the shared policy:

projects:  - id: main    networkDefaults:      svm:        # shared policy only — cluster is network identity and must not be here        commitment: confirmed        statePollerDebounce: 500ms    networks:      # chain omitted → "solana" → networkId "svm:mainnet-beta"      - architecture: svm        svm:          cluster: mainnet-beta      # explicit chain → networkId "svm:fogo:mainnet"      - architecture: svm        svm:          chain: fogo          cluster: mainnet

Both id shapes are addressable the same three ways — URL path, request-body networkId, or an alias. The fork's colon is carried inside the third path segment:

POST /main/svm/mainnet-beta   →  svm:mainnet-beta
POST /main/svm/fogo:mainnet   →  svm:fogo:mainnet
POST /main                    →  body {"networkId": "svm:fogo:mainnet", ...}

Request/response behavior

• The network label on every Prometheus metric equals the alias when set, otherwise the raw network id (evm:1, svm:mainnet-beta, svm:fogo:mainnet). This affects all erpc_network_* metrics. erpc/networks.go:L278-286 (opens in a new tab)
• Static-response hits short-circuit before the multiplexer; static_response.hit=true is set on the Network.Forward OTel span. They never read or write the cache.
• Multiplexer followers receive a copy of the leader's response; if the follower's context deadline fires before the leader completes, the error is ErrNetworkRequestTimeout (HTTP 504 status code, JSON-RPC error code −32603). This is distinct from ErrFailsafeTimeoutExceeded (failsafe policy timeout) and ErrEndpointRequestTimeout (individual upstream HTTP timeout).
• ErrNetworkInitializing (HTTP 503) is returned while the bootstrap task is still running. The client should retry. Failed (non-fatal) bootstrap tasks are auto-retried by the background loop with factor-1.5 backoff (3 s to 130 s, task timeout 120 s).
• ErrNetworkNotSupported (HTTP 404) is returned when all providers report the chain is not supported and zero upstreams were registered. It is never retried by the bootstrap loop.
• ErrNetworkNotFound (HTTP 404) is returned after a successful bootstrap task that stored nothing (defensive path). The caller must retry.
• ErrInvalidRequest (HTTP 400) is returned when the networkId in the URL is not a valid evm:<int> format — the error message suggests using an alias or evm/42161 form. erpc/networks_registry.go:L220-222 (opens in a new tab)
• ErrNoUpstreamsFound (HTTP 404) fires when the policy engine returns an empty ordered list and the raw registration list is also empty — all upstreams have been filtered out.
• ErrUpstreamsExhausted fires when every upstream in the ordered list was tried and all failed; it carries per-upstream errors. erpc/networks.go:L1392-1406 (opens in a new tab)
• ErrNotImplemented (HTTP 501) is returned for eth_accounts and eth_sign (always); stateful methods with more than one candidate upstream also produce this error unless scoped by a use-upstream directive.
• ErrInvalidEvmChainId (HTTP 400) is returned when the chain id cannot be parsed.
• ErrNetworkRequestTimeout wire behavior: JSON-RPC error code −32603; HTTP transport status is 200 (JSON-RPC over HTTP); ErrorStatusCode() returns 504 but this is only seen in non-JSON-RPC error paths. The error is retryable toward both network and upstream (no explicit non-retryable flag). Message format: "network-level request towards one or more upstreams timed out after <N>ms" where N is the elapsed time since the follower registered with the multiplexer.
• An alias in the request body networkId field is silently ignored — the body fallback splits the literal value on : with no alias lookup. Only URL path segments resolve aliases.

Best practices

• Always set networkDefaults.failsafe before adding per-chain failsafe entries — once a network has any failsafe list, the defaults list is superseded entirely for that network.
• Use alias on every statically-declared chain you control. It makes URLs readable, shows up in every Prometheus label, and costs nothing.
• Set preserveDefaultMethods: true before adding any custom methods.definitions entry. The default false silently drops all built-in methods (including eth_call, eth_getLogs) the moment you add one definition.
• Never set finalized: true on a method that returns block-specific data (eth_getBalance, eth_getCode, etc.) — every response will be permanently cached at the first value ever returned.
• Enable servedTip.enabledFor: [latest, finalized] in production multi-pod deployments to prevent backward tip jumps across pods that could surface stale reads to clients.
• Keep getLogsMaxAllowedRange at its default 30 000 unless your upstreams document a higher limit — range splits happen automatically on oversized requests but getLogsSplitConcurrency caps parallelism at 10 to avoid flooding providers.
• For eth_sendRawTransaction in high-retry configs, leave idempotentTransactionBroadcast enabled (default). Disabling it turns idempotent "already known" errors back into real failures, making retries unsafe.

Edge cases & gotchas

1. Aliases work in URLs only, not body networkId — body fallback splits on : with no alias lookup; only parseUrlPath resolves aliases. erpc/http_server.go:L613-634 (opens in a new tab)
2. Unknown alias segment falls through silently — an unresolvable single path segment is treated as architecture, yielding "architecture is not valid (must be 'evm')" instead of an alias-not-found error.
3. directiveDefaults is all-or-nothing — a network-level directiveDefaults block completely replaces networkDefaults.directiveDefaults; individual fields are not merged. common/defaults.go:L1837-1840 (opens in a new tab)
4. failsafe replaces, not merges — any networks[].failsafe list supersedes networkDefaults.failsafe entirely for that network.
5. preserveDefaultMethods: false + one custom definitions entry drops ALL built-ins — including eth_call, eth_getLogs, etc. Only the custom entries plus the 6 stateful markers survive. common/defaults.go:L561-573 (opens in a new tab)
6. finalized: true on a non-finalized method permanently caches all responses — every response is placed in the finalized cache bucket (long/permanent TTL). Setting this on eth_getBalance would permanently cache every balance at the first value returned. erpc/networks.go:L1656-1660 (opens in a new tab)
7. networkDefaults.multiplexing has no deep merge — a network must set its own multiplexing field; there is no per-network override via defaults alone.
8. Legacy single-object networkDefaults.failsafe silently drops multiplexing — the old-format fallback struct has no Multiplexing field. common/config.go:L626-655 (opens in a new tab)
9. Lazily-exposed networks never get a metrics alias resolver entry — erpc/init.go builds the map only from static cfg.Projects[].Networks[]; gRPC-cache metrics for lazy networks show the raw networkId. erpc/init.go:L62-77 (opens in a new tab)
10. evm.enforceBlockAvailability: false overrides upstream bounds — step 3 of the enforcement chain (upstream-has-bounds) is only reached when steps 1–2 yield no decision; an explicit false at the network level (step 2) short-circuits it. erpc/networks.go:L1814-1817 (opens in a new tab)
11. Static response error code 0 is omitted from the wire response — Code is tagged json:"code,omitempty" on int, so 0 disappears from the JSON error object. Always use a non-zero code in production. common/errors.go:L2226 (opens in a new tab)
12. Failsafe merge picks the FIRST matching default — ordering of networkDefaults.failsafe entries matters when multiple wildcard entries could match.
13. stateful: false on a built-in stateful method is silently overridden — MethodsConfig.SetDefaults force-sets Stateful = true for all 6 stateful methods in all three code paths, overwriting any user-supplied false without any warning. common/defaults.go:L512-573 (opens in a new tab)
14. EnforceGetLogsBlockRange and EnforceHighestBlock directives cannot be overridden per-request via HTTP headers for eth_getLogs, trace_filter, arbtrace_filter, and eth_blockNumber — these hooks read from the config baked in at startup, not live per-request directives. Set enforceGetLogsBlockRange: false in directiveDefaults, not as an HTTP header. architecture/evm/eth_getLogs.go:L282-285 (opens in a new tab)
15. ErrNetworkRequestTimeout is produced only in the multiplexer follower path — a request that is itself the leader experiences ErrFailsafeTimeoutExceeded or upstream sweep errors, never ErrNetworkRequestTimeout. erpc/networks.go:L2079-2084 (opens in a new tab)
16. evm.chainId: 0 is not rejected — chainId: 0 produces networkId = evm:0, which passes util.IsValidNetworkId but is excluded by provider onlyNetworks/ignoreNetworks lists that use the stricter chainId > 0 check.
17. translateLatestTag: false on a non-historical method collapses all callers to one cache key — all requests for that method share the literal "latest" key; stale data is returned until the cache TTL expires.
18. preserveDefaultMethods: false with NO definitions block keeps ALL built-ins — the drop-all behavior only triggers when definitions is non-empty AND preserveDefaultMethods is false. A config with methods: { preserveDefaultMethods: false } and no definitions key is identical to omitting the methods block entirely. common/defaults.go:L494 (opens in a new tab)
19. Lazy network alias registration happens after first bootstrap — statically-declared networks register aliases eagerly in the NetworksRegistry constructor; lazily-created networks only register their alias inside prepareNetwork, which runs during bootstrap. Until bootstrap completes, alias-based URLs for lazy networks return an alias-not-found error. erpc/networks_registry.go:L322-328 (opens in a new tab)
20. Failed lazy bootstrap is user-retryable — non-fatal bootstrap tasks are retried by the background auto-retry loop and by the next request's ExecuteTasks. Only resolveNetworkConfig format errors are TaskFatal and never retried. erpc/networks_registry.go:L263-266 (opens in a new tab)
21. Provider onlyNetworks bypasses vendor support checks entirely — a networkId listed in onlyNetworks returns SupportsNetwork = true without consulting the vendor's dynamic check; ignoreNetworks is evaluated first and short-circuits to false. thirdparty/provider.go:L34-49 (opens in a new tab)
22. Synthesized lazy network configs become permanently visible — ExposeNetworkConfig appends to project.Config.Networks (admin API surface) and never overwrites an existing entry, so lazy networks persist in the admin response after first use. erpc/projects.go:L58-77 (opens in a new tab)
23. Syncing upstreams are excluded from every head computation — max mode, cluster mode, lowest-finalized, and guaranteed-method floor calculations all skip upstreams in EvmSyncingStateSyncing. erpc/networks.go:L327-330 (opens in a new tab)
24. Future-block short-circuit compares against the MAX eligible head, not the cluster-min served tip — it never nulls a block that the most-ahead upstream reports having. The synthetic null response is never cached, and the short-circuit only fires for concrete block numbers (not tags or hashes). erpc/networks.go:L570-610 (opens in a new tab)
25. Wrong-empty misbehavior is suppressed for out-of-bounds blocks — if the block number in a missing-data response falls outside an upstream's configured blockAvailability bounds, the empty response is expected and no misbehavior is recorded against that upstream. erpc/networks.go:L1566-1587 (opens in a new tab)
26. getLogsMaxAllowedRange: 0 is rejected by validation — the field must be > 0 after defaults (common/validation.go:L1309-1311). Unlike getLogsMaxAllowedAddresses and getLogsMaxAllowedTopics (which default to 0 = unlimited), getLogsMaxAllowedRange defaults to 30 000 and cannot be explicitly zeroed out; setting 0 in a network inheriting from defaults is treated as "unset" and inherits the parent value. common/defaults.go:L2092-2094 (opens in a new tab)
27. Zero projects → implicit main project + catch-all aliasing rule — when the config has no projects, eRPC auto-creates {matchDomain: "*", serveProject: "main"}, so /evm/123 works without a project path segment. common/defaults.go:L100-110 (opens in a new tab)
28. Selector-scoped tips never pollute network gauges — stateless scoped picks (unmatched or non-simple selectors) use a sentinel lane and emit no Prometheus gauge; equivalent selectors dedup into one partition keyed by matched-set hash; the cap of 16 partitions is enforced globally per network. erpc/networks.go:L98-105 (opens in a new tab)
29. Static response params matching has no wildcard — there is no glob or * support; every params slot must match exactly. To catch a method regardless of params, add an entry with an empty params array. To match block 0 ("0x0"), be exact — "0x00" will not match. common/static_response.go:L14-99 (opens in a new tab)

Observability

Notable logs (zerolog, at erpc/networks_registry.go and erpc/networks.go unless noted):

• "registered network alias" / "skipping duplicate alias registration with different target" — alias map events.
• "network initialization ended with zero upstreams" — bootstrap completed but no upstreams were registered.
• "networks bootstrap completed" / "failed to bootstrap networks in background" — startup background bootstrap outcome.
• "response served from cache" — cache hit in the forward pipeline.
• "found identical request initiating multiplexer" — multiplexer follower registered.
• "block availability check failed; failing open to allow request" — block-availability extraction or poller error; request proceeds.
• "served static response (no upstream contacted)" (debug) — static response matched and served (erpc/networks_static_responses.go).
• "skipping static response: cannot inspect request" (debug) — JsonRpcRequest() failed; static check skipped.
• "failed to build static response" (error) — NewJsonRpcResponse failed on a matched static entry.
• Provider task: "registering N upstream(s) from provider" (upstream/registry.go).

Source code entry points

• erpc/networks_registry.go:L83-376 (opens in a new tab) — NetworksRegistry: lazy GetNetwork, bootstrap tasks, resolveNetworkConfig synthesis, alias map register/resolve, NewNetwork constructor.
• erpc/networks.go:L931-1603 (opens in a new tab) — Network.Forward: full request pipeline, failsafe-executor matching, static responses, multiplexing, cache, upstream ordering, block-availability gating, finality classification.
• common/defaults.go:L1781-1973 (opens in a new tab) — NetworkConfig.SetDefaults: networkDefaults inheritance, per-field fill rules, EvmNetworkConfig/MethodsConfig/DirectiveDefaults sub-passes.
• erpc/http_server.go:L810-1006 (opens in a new tab) — parseUrlPath: URL/alias parsing decision table, domain-aliasing rules, body-networkId fallback.
• common/config.go:L1995-2256 (opens in a new tab) — NetworkConfig, EvmNetworkConfig struct definitions, legacy single-failsafe decode, NetworkId().
• upstream/registry.go:L155-293 (opens in a new tab) — PrepareUpstreamsForNetwork: provider fan-out, ready-wait, 503/404 error states.
• erpc/networks_static_responses.go (opens in a new tab) — tryServeStaticResponse: canned-response serving, metric emit.
• common/static_response.go:L14-99 (opens in a new tab) — FindStaticResponseMatch, paramsEqual, valueEqual: pure matching logic (YAML int vs JSON float64 tolerance, map key order independence).

Related pages

• SVM commitment & finality — how svm.commitment is injected and how SVM finality is classified.
• SVM slot tracking & health — the state poller behind statePollerDebounce, plus maxFinalizedSlotLag and enforceBlockAvailability in depth.
• SVM JSON-RPC cache — caching for SVM networks.
• Static responses — full matching semantics and edge cases for canned replies.
• Selection & scoring — upstream ordering within a network.
• Retry — per-network failsafe retry policy.
• Hedge — parallel backup requests on slow upstreams.
• Timeout — bounds the upstream sweep from outside.
• Rate limiters — budgets referenced by rateLimitBudget.
• Survive provider outages — the outcome networks + failsafe deliver together.