@rhinestone/shared-configs 2.7.0 → 2.8.0

package/dist/configs/chain-indexer.json

@@ -0,0 +1,301 @@
+{
+    "1": {
+        "finality": "probabilistic",
+        "finality_poll_interval_ms": 30000,
+        "finality_source": "finalized",
+        "grace_ms": 60000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 3000,
+        "reorg_window_k": 32,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "10": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "56": {
+        "finality": "probabilistic",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 32,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "100": {
+        "finality": "probabilistic",
+        "finality_poll_interval_ms": 30000,
+        "finality_source": "finalized",
+        "grace_ms": 60000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 2000,
+        "reorg_window_k": 32,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "130": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "137": {
+        "finality": "probabilistic",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 64,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "143": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "146": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "196": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "999": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "1868": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "4663": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "8453": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "9745": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "9746": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 5000
+    },
+    "42161": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "43114": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "57073": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "84532": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 8,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 5000
+    },
+    "421614": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 8,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 5000
+    },
+    "747474": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 16,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000
+    },
+    "11155111": {
+        "finality": "probabilistic",
+        "finality_poll_interval_ms": 30000,
+        "finality_source": "finalized",
+        "grace_ms": 60000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 3000,
+        "reorg_window_k": 32,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 5000
+    },
+    "11155420": {
+        "finality": "sequencer",
+        "finality_poll_interval_ms": 15000,
+        "finality_source": "finalized",
+        "grace_ms": 30000,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 4,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 8,
+        "reverify_delay_ms": 500,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 5000
+    }
+}

package/dist/scripts/__tests__/validation.test.js

@@ -8,6 +8,7 @@ const viem_1 = require("viem");
 const validation_1 = require("../validation");
 const index_1 = require("../../src/index");
 const oft_json_1 = __importDefault(require("../../configs/oft.json"));
+const chain_indexer_json_1 = __importDefault(require("../../configs/chain-indexer.json"));
 const nativeToken = { address: "0x0", symbol: "ETH", decimals: 18 };
 const usdcAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
 const validAuthorization = {
@@ -497,6 +498,132 @@ function errorsFor(chain) {
         (0, bun_test_1.expect)((0, validation_1.validateOftCoverage)({}, { USDT0: { adapters: { "1": "0xa" } } })).toEqual([]);
     });
 });
+/** A complete class-B entry, so semantic tests don't trip the shape checks. */
+function validIndexerEntry(overrides = {}) {
+    return {
+        poll_interval_ms: 1000,
+        streaming_poll_interval_ms: 15000,
+        reorg_window_k: 16,
+        reverify_delay_ms: 500,
+        max_catchup_blocks: 5000,
+        parse_concurrency: 4,
+        scan_batch_max_blocks: 200,
+        finality: "sequencer",
+        finality_source: "finalized",
+        finality_poll_interval_ms: 15000,
+        grace_ms: 30000,
+        ...overrides,
+    };
+}
+(0, bun_test_1.describe)("validateChainIndexerCoverage", () => {
+    // What actually reaches the artifact: the shipped registry and the shipped
+    // settings must agree, or the release pipeline breaks on good data.
+    (0, bun_test_1.it)("classifies every real EVM chain", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIndexerCoverage)(index_1.chainRegistry, chain_indexer_json_1.default)).toEqual([]);
+    });
+    (0, bun_test_1.it)("reports an EVM chain with no entry", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {});
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("no chain-indexer entry");
+    });
+    (0, bun_test_1.it)("reports an entry addressing no real EVM chain", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({}, {
+            "1": validIndexerEntry(),
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("no real EVM chain");
+    });
+    // HyperCore is vmType "evm" with a hypercore: caip2 — the eip155 namespace,
+    // not vmType, decides whether the indexer dials a chain.
+    (0, bun_test_1.it)("requires nothing of a virtual or non-eip155 chain", () => {
+        const chains = {
+            "1337001": validChain({ caip2: "hypercore:spot", virtual: true }),
+            "728126428": validChain({ vmType: "tvm", caip2: "tron:mainnet" }),
+        };
+        (0, bun_test_1.expect)((0, validation_1.validateChainIndexerCoverage)(chains, {})).toEqual([]);
+    });
+    (0, bun_test_1.it)("rejects a non-object entry", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": 42,
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("not an object");
+    });
+    bun_test_1.it.each([
+        [
+            "a missing field",
+            { poll_interval_ms: undefined },
+            "missing `poll_interval_ms`",
+        ],
+        [
+            "a non-integer value",
+            { reorg_window_k: "16" },
+            "`reorg_window_k` = \"16\" is not a legal value",
+        ],
+        [
+            "an unknown finality class",
+            { finality: "optimistic" },
+            "`finality` = \"optimistic\" is not a legal value",
+        ],
+        [
+            "an unrecognized field",
+            { pol_interval_ms: 1000 },
+            "unrecognized field `pol_interval_ms`",
+        ],
+        [
+            "instant finality with a real finality source",
+            { finality: "instant" },
+            "instant chains take neither",
+        ],
+        [
+            "an instant source that still polls",
+            {
+                finality: "instant",
+                finality_source: "instant",
+                finality_poll_interval_ms: 15000,
+            },
+            "does not match finality_source",
+        ],
+        [
+            "a streaming poll below the base poll",
+            { streaming_poll_interval_ms: 500 },
+            "never a speedup",
+        ],
+    ])("rejects %s", (_label, overrides, expected) => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": validIndexerEntry(overrides),
+        });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain(expected);
+    });
+    (0, bun_test_1.it)("accepts { indexed: false } as a complete entry", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": { indexed: false },
+        })).toEqual([]);
+    });
+    (0, bun_test_1.it)("rejects indexed: false carrying scan settings", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": { indexed: false, poll_interval_ms: 1000 },
+        });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain("an opt-out is the whole entry");
+    });
+    (0, bun_test_1.it)("rejects indexed: true", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": validIndexerEntry({ indexed: true }),
+        });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain("the only legal value is false");
+    });
+    (0, bun_test_1.it)("accepts a coherent instant-class entry", () => {
+        const entry = validIndexerEntry({
+            finality: "instant",
+            finality_source: "instant",
+            finality_poll_interval_ms: 0,
+            reverify_delay_ms: 0,
+            grace_ms: 0,
+            reorg_window_k: 4,
+        });
+        (0, bun_test_1.expect)((0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, { "1": entry })).toEqual([]);
+    });
+});
 (0, bun_test_1.describe)("formatValidationIssues", () => {
     (0, bun_test_1.it)("returns empty string for no issues", () => {
         (0, bun_test_1.expect)((0, validation_1.formatValidationIssues)({ issues: [], hasErrors: false })).toBe("");

package/dist/scripts/generate.js

@@ -434,6 +434,11 @@ async function generate() {
     // and reads its addresses back out of the OFT registry, so only an adapter
     // added there without the matching chain entry can drift.
     const oftCoverageIssues = (0, validation_1.validateOftCoverage)(classifiedChains, output.oft);
+    // Chain-indexer settings are authored, not derived (config/chain-indexer.jsonnet),
+    // and the indexer hard-fails on an unclassified chain — so an EVM chain added
+    // without an entry fails this build instead of the indexer's boot. Needs the
+    // stamped caip2, hence after the classifiers.
+    const chainIndexerIssues = (0, validation_1.validateChainIndexerCoverage)(classifiedChains, output.chainIndexer);
     const classificationIssues = [
         ...networkIssues,
         ...stackIssues,
@@ -442,6 +447,7 @@ async function generate() {
         ...publicRpcUrlIssues,
         ...iconSlugIssues,
         ...oftCoverageIssues,
+        ...chainIndexerIssues,
     ];
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "chains.json"), `${JSON.stringify(classifiedChains, null, 2)}\n`);
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "mainnets.json"), `${JSON.stringify(output.mainnets, null, 2)}\n`);
@@ -449,6 +455,7 @@ async function generate() {
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "providers.json"), `${JSON.stringify(output.providers, null, 2)}\n`);
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "oft.json"), `${JSON.stringify(output.oft, null, 2)}\n`);
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "oft-programs.json"), `${JSON.stringify(output.oftProgramIds ?? {}, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "chain-indexer.json"), `${JSON.stringify(output.chainIndexer, null, 2)}\n`);
     // Validate chain configuration. Classification problems are reported in the
     // same pass so one run surfaces everything wrong with the registry, rather than
     // failing on the partition and hiding the rest.

package/dist/scripts/validation.d.ts

@@ -225,6 +225,25 @@ export declare function validateChainConfig(chains: ChainRegistry): ValidationRe
  * a diff of either file on its own — this is the check that sees both.
  */
 export declare function validateOftCoverage(chains: ChainRegistry, oft: Record<string, unknown>): ValidationIssue[];
+/**
+ * Insists that every real EVM chain carries a complete, coherent chain-indexer
+ * entry, and that no entry addresses a chain that does not exist.
+ *
+ * The indexer scans every dialable EVM chain, and its contract is that an
+ * unclassified chain is a hard failure — this check moves that failure from
+ * the indexer's boot to this build, where the person adding the chain sees it
+ * (RHI-6107). Selected by the `eip155:` caip2 namespace, NOT by vmType:
+ * HyperCore is vmType "evm" with a `hypercore:` caip2 and must not require an
+ * entry — the same discriminator the publish workflow's contracts guard uses,
+ * for the same reason. Runs after `classifyChainCaip2`, which stamps the field.
+ *
+ * The cross-field rules mirror chain-indexer's `ChainScanSettings::validate`,
+ * so a value set this check accepts is one the indexer will accept.
+ *
+ * A chain deliberately not indexed carries `{ indexed: false }` as its whole
+ * entry — a decision the check accepts, unlike a missing entry.
+ */
+export declare function validateChainIndexerCoverage(chains: ChainRegistry, chainIndexer: Record<string, unknown>): ValidationIssue[];
 /**
  * Formats validation issues for console output.
  *

package/dist/scripts/validation.js

@@ -41,6 +41,7 @@ exports.classifyChainPublicRpcUrls = classifyChainPublicRpcUrls;
 exports.classifyChainStacks = classifyChainStacks;
 exports.validateChainConfig = validateChainConfig;
 exports.validateOftCoverage = validateOftCoverage;
+exports.validateChainIndexerCoverage = validateChainIndexerCoverage;
 exports.formatValidationIssues = formatValidationIssues;
 const viem_1 = require("viem");
 const celo_1 = require("viem/celo");
@@ -1143,6 +1144,133 @@ function validateOftCoverage(chains, oft) {
     }
     return issues;
 }
+// Runtime mirrors of chain-indexer's `Finality` / `FinalitySource` Rust enums
+// (chain-indexer src/config.rs). Same build-time-only rationale as the sets at
+// the top of this file: a value outside these means the jsonnet invented a
+// classification the consumer cannot deserialize, which must fail the build
+// here rather than the indexer's boot. `safe` is legal and currently unused.
+const CHAIN_INDEXER_FINALITY = new Set([
+    'probabilistic',
+    'sequencer',
+    'instant',
+]);
+const CHAIN_INDEXER_FINALITY_SOURCE = new Set([
+    'finalized',
+    'safe',
+    'instant',
+]);
+// Every field of one chain-indexer entry, all required. The wire is exact on
+// purpose: the indexer's own contract is "every field mandatory — a knob nobody
+// set is a decision nobody made", so a missing field here is the same authoring
+// mistake as a missing entry, and an unrecognized field is a typo that would
+// otherwise ship silently.
+const CHAIN_INDEXER_FIELDS = {
+    poll_interval_ms: isNonNegativeInt,
+    streaming_poll_interval_ms: isNonNegativeInt,
+    reorg_window_k: isNonNegativeInt,
+    reverify_delay_ms: isNonNegativeInt,
+    max_catchup_blocks: isNonNegativeInt,
+    parse_concurrency: isNonNegativeInt,
+    scan_batch_max_blocks: isNonNegativeInt,
+    finality: (v) => typeof v === 'string' && CHAIN_INDEXER_FINALITY.has(v),
+    finality_source: (v) => typeof v === 'string' && CHAIN_INDEXER_FINALITY_SOURCE.has(v),
+    finality_poll_interval_ms: isNonNegativeInt,
+    grace_ms: isNonNegativeInt,
+};
+/**
+ * Insists that every real EVM chain carries a complete, coherent chain-indexer
+ * entry, and that no entry addresses a chain that does not exist.
+ *
+ * The indexer scans every dialable EVM chain, and its contract is that an
+ * unclassified chain is a hard failure — this check moves that failure from
+ * the indexer's boot to this build, where the person adding the chain sees it
+ * (RHI-6107). Selected by the `eip155:` caip2 namespace, NOT by vmType:
+ * HyperCore is vmType "evm" with a `hypercore:` caip2 and must not require an
+ * entry — the same discriminator the publish workflow's contracts guard uses,
+ * for the same reason. Runs after `classifyChainCaip2`, which stamps the field.
+ *
+ * The cross-field rules mirror chain-indexer's `ChainScanSettings::validate`,
+ * so a value set this check accepts is one the indexer will accept.
+ *
+ * A chain deliberately not indexed carries `{ indexed: false }` as its whole
+ * entry — a decision the check accepts, unlike a missing entry.
+ */
+function validateChainIndexerCoverage(chains, chainIndexer) {
+    const issues = [];
+    const requiresEntry = (chain) => typeof chain.caip2 === 'string' &&
+        chain.caip2.startsWith('eip155:') &&
+        chain.virtual !== true;
+    for (const [chainId, chain] of Object.entries(chains)) {
+        if (!requiresEntry(chain))
+            continue;
+        if (chainIndexer[chainId] === undefined) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName: isNonEmptyString(chain.name) ? chain.name : '<unnamed>',
+                message: 'EVM chain has no chain-indexer entry — classify it in config/chain-indexer.jsonnet (see docs/add-chain.md, "Classify the chain for the indexer")',
+            });
+        }
+    }
+    for (const [chainId, entry] of Object.entries(chainIndexer)) {
+        const chain = chains[chainId];
+        const chainName = chain && isNonEmptyString(chain.name) ? chain.name : '<not in registry>';
+        const issue = (message) => issues.push({ severity: 'error', chainId, chainName, message });
+        if (!chain || !requiresEntry(chain)) {
+            issue('chain-indexer entry addresses no real EVM chain — remove it from config/chain-indexer.jsonnet, or add the chain first');
+            continue;
+        }
+        if (!isObject(entry)) {
+            issue('chain-indexer entry is not an object');
+            continue;
+        }
+        // `{ indexed: false }` is a complete entry: the explicit decision "this
+        // chain is not indexed" — as opposed to a missing entry, which is no
+        // decision at all and fails coverage above. Nothing may ride along: scan
+        // settings on a chain that is not scanned are a contradiction, and
+        // `indexed: true` is what a full entry already says.
+        if ('indexed' in entry) {
+            if (entry.indexed !== false) {
+                issue(`chain-indexer \`indexed\` = ${JSON.stringify(entry.indexed)} — the only legal value is false (a full entry already means indexed)`);
+            }
+            const extras = Object.keys(entry).filter((field) => field !== 'indexed');
+            if (extras.length) {
+                issue(`chain-indexer entry sets indexed: false but also carries ${extras.map((field) => `\`${field}\``).join(', ')} — an opt-out is the whole entry, it takes no scan settings`);
+            }
+            continue;
+        }
+        for (const [field, check] of Object.entries(CHAIN_INDEXER_FIELDS)) {
+            if (entry[field] === undefined) {
+                issue(`chain-indexer entry is missing \`${field}\` — every field is mandatory, a knob nobody set is a decision nobody made`);
+            }
+            else if (!check(entry[field])) {
+                issue(`chain-indexer \`${field}\` = ${JSON.stringify(entry[field])} is not a legal value`);
+            }
+        }
+        for (const field of Object.keys(entry)) {
+            if (!(field in CHAIN_INDEXER_FIELDS)) {
+                issue(`chain-indexer entry carries unrecognized field \`${field}\` — the artifact's shape is exact, fix the name or drop it`);
+            }
+        }
+        const instantClass = entry.finality === 'instant';
+        const instantSource = entry.finality_source === 'instant';
+        if (instantClass !== instantSource) {
+            issue(`finality = ${JSON.stringify(entry.finality)} but finality_source = ${JSON.stringify(entry.finality_source)} — instant chains take neither the reorg nor the watermark path, everything else needs a real finality tag`);
+        }
+        if (isNonNegativeInt(entry.finality_poll_interval_ms) &&
+            instantSource !== (entry.finality_poll_interval_ms === 0)) {
+            issue(`finality_poll_interval_ms = ${entry.finality_poll_interval_ms} does not match finality_source = ${JSON.stringify(entry.finality_source)} — 0 exactly when the source is instant`);
+        }
+        const streaming = entry.streaming_poll_interval_ms;
+        const poll = entry.poll_interval_ms;
+        if (typeof streaming === 'number' &&
+            typeof poll === 'number' &&
+            streaming < poll) {
+            issue(`streaming_poll_interval_ms = ${streaming} is below poll_interval_ms = ${poll} — the poll under a connected stream is a relaxation, never a speedup`);
+        }
+    }
+    return issues;
+}
 /**
  * Formats validation issues for console output.
  *

package/dist/src/generated/packageVersion.d.ts

@@ -1,2 +1,2 @@
-declare const PACKAGE_VERSION = "2.7.0";
+declare const PACKAGE_VERSION = "2.8.0";
 export { PACKAGE_VERSION };

package/dist/src/generated/packageVersion.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_VERSION = void 0;
 // Auto-generated by scripts/generate.ts. Do not edit manually.
-const PACKAGE_VERSION = "2.7.0";
+const PACKAGE_VERSION = "2.8.0";
 exports.PACKAGE_VERSION = PACKAGE_VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/shared-configs",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Reusable configuration files for Rhinestone services",
   "author": {
     "name": "Rhinestone",