envio 3.5.0-alpha.3 → 3.5.0

package/src/db/IndexManager.res.mjs

@@ -0,0 +1,130 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as IndexCatalog from "./IndexCatalog.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as IndexDefinition from "./IndexDefinition.res.mjs";
+
+function make() {
+  return {
+    catalog: IndexCatalog.make(),
+    inflight: {},
+    tableQueue: {}
+  };
+}
+
+function reload(manager, rows) {
+  manager.catalog = IndexCatalog.fromRows(rows);
+  return manager.catalog;
+}
+
+function catalog(manager) {
+  return manager.catalog;
+}
+
+function isSatisfied(manager, definition, coverage) {
+  return Stdlib_Option.isSome(IndexCatalog.find(manager.catalog, definition, coverage));
+}
+
+function conflictError(entry, definition, pgSchema) {
+  return new Error(`Cannot create the index "` + entry.name + `" in schema "` + pgSchema + `" for ` + IndexDefinition.describe(definition) + `. A different index already holds that name and the indexer can't safely replace it: ` + Stdlib_Option.getOr(IndexCatalog.rejectReason(entry, definition, "Exact"), "it is unique") + `. Drop that index by hand, then restart the indexer.`);
+}
+
+function verificationError(name, definition, pgSchema, reason) {
+  return new Error(`The index "` + name + `" in schema "` + pgSchema + `" is not usable after its DDL ran: ` + reason + `. It was meant to cover ` + IndexDefinition.describe(definition) + `. Drop it by hand, then restart the indexer.`);
+}
+
+function prepare(manager, definition, coverage, pgSchema) {
+  let match = IndexCatalog.find(manager.catalog, definition, coverage);
+  if (match !== undefined) {
+    return;
+  }
+  let name = IndexDefinition.name(definition);
+  let create = IndexDefinition.makeCreateQuery(definition, pgSchema);
+  let entry = IndexCatalog.getByName(manager.catalog, name);
+  if (entry === undefined) {
+    return {
+      definition: definition,
+      name: name,
+      isRebuild: false,
+      queries: [create]
+    };
+  }
+  if (IndexCatalog.isExactly(entry, definition)) {
+    return {
+      definition: definition,
+      name: name,
+      isRebuild: true,
+      queries: [
+        IndexDefinition.makeDropQuery(pgSchema, name),
+        create
+      ]
+    };
+  }
+  throw conflictError(entry, definition, pgSchema);
+}
+
+function verifyOrThrow(prepared, rows, pgSchema) {
+  let name = prepared.name;
+  let definition = prepared.definition;
+  let entry = rows.map(IndexCatalog.fromRow).find(entry => entry.name === name);
+  if (entry !== undefined) {
+    let reason = IndexCatalog.rejectReason(entry, definition, "Exact");
+    if (reason !== undefined) {
+      throw verificationError(name, definition, pgSchema, reason);
+    }
+    return entry;
+  }
+  throw verificationError(name, definition, pgSchema, "PostgreSQL has no such index");
+}
+
+function record(manager, entry) {
+  IndexCatalog.set(manager.catalog, entry);
+}
+
+function resync(manager, name, rows) {
+  let entry = rows.map(IndexCatalog.fromRow).find(entry => entry.name === name);
+  if (entry !== undefined) {
+    return IndexCatalog.set(manager.catalog, entry);
+  } else {
+    return IndexCatalog.remove(manager.catalog, name);
+  }
+}
+
+function ensure(manager, definition, coverage, build) {
+  if (isSatisfied(manager, definition, coverage)) {
+    return Promise.resolve();
+  }
+  let key = IndexCatalog.coverageKey(coverage) + IndexDefinition.key(definition);
+  let promise = manager.inflight[key];
+  if (promise !== undefined) {
+    return promise;
+  }
+  let tail = manager.tableQueue[definition.tableName];
+  let tail$1 = tail !== undefined ? tail : Promise.resolve();
+  let promise$1 = tail$1.then(() => {
+    if (isSatisfied(manager, definition, coverage)) {
+      return Promise.resolve();
+    } else {
+      return build();
+    }
+  });
+  manager.inflight[key] = promise$1;
+  manager.tableQueue[definition.tableName] = Utils.$$Promise.silentCatch(promise$1);
+  return promise$1.finally(() => Utils.Dict.deleteInPlace(manager.inflight, key));
+}
+
+export {
+  make,
+  reload,
+  catalog,
+  isSatisfied,
+  conflictError,
+  verificationError,
+  prepare,
+  verifyOrThrow,
+  record,
+  resync,
+  ensure,
+}
+/* Utils Not a pure module */

package/src/db/InternalTable.res

@@ -56,7 +56,7 @@ module Chains = {
   }
 
   type t = {
-    @as("id") id: int,
+    @as("id") id: ChainId.t,
     @as("start_block") startBlock: int,
     @as("end_block") endBlock: Null.t<int>,
     @as("max_reorg_depth") maxReorgDepth: int,
@@ -69,7 +69,7 @@ module Chains = {
   let table = mkTable(
     "envio_chains",
     ~fields=[
-      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#id: field :> string), ChainId, ~fieldSchema=ChainId.schema, ~isPrimaryKey),
       // Values populated from config
       mkField((#start_block: field :> string), Int32, ~fieldSchema=S.int),
       mkField((#end_block: field :> string), Int32, ~fieldSchema=S.null(S.int), ~isNullable),
@@ -164,15 +164,24 @@ SET ${setClauses->Array.joinUnsafe(",\n    ")}
 WHERE "${(#id: field :> string)}" = $1;`
   }
 
-  // Written in the same transaction as the deferred schema indexes, so a chain
-  // is never reported ready without the indexes the schema promises.
+  // Written only once every schema-defined index is verified, so a chain is
+  // never reported ready without the indexes the schema promises. One row at a
+  // time, like `setMeta`: the id column is INTEGER or BIGINT depending on the
+  // configured `ChainId.mode`, and a bare `= $2` needs no cast either way.
+  //
+  // `IS NULL` so a chain keeps the timestamp it first caught up at, matching the
+  // sticky in-memory `ChainState.markReady`. Without it a partial recovery (eg a
+  // chain added to an already-synced indexer) would restamp the ready chains in
+  // the database while their in-memory copies kept the old value — and the next
+  // chain-metadata write would push the stale value back over the committed one.
   let makeSetReadyAtQuery = (~pgSchema) =>
     `UPDATE "${pgSchema}"."${table.tableName}"
 SET "${(#ready_at: field :> string)}" = $1
-WHERE "${(#id: field :> string)}" = ANY($2::int[]);`
+WHERE "${(#id: field :> string)}" = $2
+  AND "${(#ready_at: field :> string)}" IS NULL;`
 
   type rawInitialState = {
-    id: int,
+    id: ChainId.t,
     startBlock: int,
     endBlock: Null.t<int>,
     maxReorgDepth: int,
@@ -198,7 +207,7 @@ FROM "${pgSchema}"."${table.tableName}";`
   }
 
   type rawIndexingAddress = {
-    chainId: int,
+    chainId: ChainId.t,
     address: Address.t,
     contractName: string,
     registrationBlock: int,
@@ -231,7 +240,9 @@ FROM "${pgSchema}"."${EnvioAddresses.table.tableName}";`
 
     let indexingAddressesByChainId = Dict.make()
     rawIndexingAddresses->Array.forEach(row => {
-      let key = row.chainId->Int.toString
+      // BIGINT chain ids come back as strings; normalizing here keeps the
+      // grouping key identical to the one derived from the chains rows below.
+      let key = row.chainId->ChainId.normalizeOrThrow->ChainId.toString
       let addresses = switch indexingAddressesByChainId->Dict.get(key) {
       | Some(addresses) => addresses
       | None =>
@@ -249,10 +260,14 @@ FROM "${pgSchema}"."${EnvioAddresses.table.tableName}";`
     })
 
     rawInitialStates->Array.map(rawInitialState => {
-      ...rawInitialState,
-      indexingAddresses: indexingAddressesByChainId
-      ->Dict.get(rawInitialState.id->Int.toString)
-      ->Option.getOr([]),
+      let id = rawInitialState.id->ChainId.normalizeOrThrow
+      {
+        ...rawInitialState,
+        id,
+        indexingAddresses: indexingAddressesByChainId
+        ->Dict.get(id->ChainId.toString)
+        ->Option.getOr([]),
+      }
     })
   }
 
@@ -295,7 +310,7 @@ WHERE "id" = $1;`
   }
 
   type progressedChain = {
-    chainId: int,
+    chainId: ChainId.t,
     progressBlockNumber: int,
     sourceBlockNumber: int,
     totalEventsProcessed: float,
@@ -309,7 +324,7 @@ WHERE "id" = $1;`
     progressedChains->Array.forEach(data => {
       let params = []
 
-      params->Array.push(data.chainId->(Utils.magic: int => unknown))->ignore
+      params->Array.push(data.chainId->(Utils.magic: ChainId.t => unknown))->ignore
 
       progressFields->Array.forEach(field => {
         params
@@ -393,7 +408,7 @@ module Checkpoints = {
   type t = {
     id: bigint,
     @as("chain_id")
-    chainId: int,
+    chainId: ChainId.t,
     @as("block_number")
     blockNumber: int,
     @as("block_hash")
@@ -405,7 +420,7 @@ module Checkpoints = {
   // Schema for parsing DB results where BIGINT columns come back as strings
   let dbSchema = S.object(s => {
     id: s.field("id", Utils.BigInt.schema),
-    chainId: s.field("chain_id", S.int),
+    chainId: s.field("chain_id", ChainId.schema),
     blockNumber: s.field("block_number", S.int),
     blockHash: s.field(
       "block_hash",
@@ -423,7 +438,7 @@ module Checkpoints = {
     "envio_checkpoints",
     ~fields=[
       mkField((#id: field :> string), UInt64, ~fieldSchema=S.bigint, ~isPrimaryKey),
-      mkField((#chain_id: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#chain_id: field :> string), ChainId, ~fieldSchema=ChainId.schema),
       mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
       mkField((#block_hash: field :> string), String, ~fieldSchema=S.null(S.string), ~isNullable),
       mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
@@ -460,9 +475,17 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
     `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->BigInt.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
   }
 
-  let makeInsertCheckpointQuery = (~pgSchema) => {
+  let makeInsertCheckpointQuery = (~pgSchema, ~chainIdMode: ChainId.mode=Int32) => {
+    let chainIdArrayType = Table.getPgFieldType(
+      ~fieldType=ChainId,
+      ~pgSchema,
+      ~isArray=true,
+      ~isNumericArrayAsText=false,
+      ~isNullable=false,
+      ~chainIdMode,
+    )
     `INSERT INTO "${pgSchema}"."${table.tableName}" ("${(#id: field :> string)}", "${(#chain_id: field :> string)}", "${(#block_number: field :> string)}", "${(#block_hash: field :> string)}", "${(#events_processed: field :> string)}")
-SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Integer: Postgres.columnType :> string)}[],$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
+SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${chainIdArrayType},$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
   }
 
   let insert = (
@@ -473,8 +496,9 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Int
     ~checkpointBlockNumbers,
     ~checkpointBlockHashes,
     ~checkpointEventsProcessed,
+    ~chainIdMode: ChainId.mode=Int32,
   ) => {
-    let query = makeInsertCheckpointQuery(~pgSchema)
+    let query = makeInsertCheckpointQuery(~pgSchema, ~chainIdMode)
 
     // Convert bigint arrays to string arrays for postgres driver compatibility
     let checkpointIdStrings = checkpointIds->Utils.BigInt.arrayToStringArray
@@ -489,7 +513,7 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Int
         checkpointEventsProcessed,
       )->(
         Utils.magic: (
-          (array<string>, array<int>, array<int>, array<Null.t<string>>, array<int>)
+          (array<string>, array<ChainId.t>, array<int>, array<Null.t<string>>, array<int>)
         ) => unknown
       ),
     )
@@ -530,7 +554,7 @@ LIMIT 1;`
   let getRollbackTargetCheckpoint = (
     sql,
     ~pgSchema,
-    ~reorgChainId: int,
+    ~reorgChainId: ChainId.t,
     ~lastKnownValidBlockNumber: int,
   ) => {
     let rawResult: promise<array<{"id": string}>> =
@@ -547,7 +571,7 @@ LIMIT 1;`
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
     `SELECT 
-  "${(#chain_id: field :> string)}",
+  "${(#chain_id: field :> string)}"::float8 as "${(#chain_id: field :> string)}",
   SUM("${(#events_processed: field :> string)}") as events_processed_diff,
   MIN("${(#block_number: field :> string)}") - 1 as new_progress_block_number
 FROM "${pgSchema}"."${table.tableName}"
@@ -568,7 +592,7 @@ GROUP BY "${(#chain_id: field :> string)}";`
     ->(
       Utils.magic: promise<unknown> => promise<
         array<{
-          "chain_id": int,
+          "chain_id": ChainId.t,
           "events_processed_diff": string,
           "new_progress_block_number": int,
         }>,
@@ -581,7 +605,7 @@ module RawEvents = {
   type t = Internal.rawEvent
 
   let schema = S.schema((s): t => {
-    chain_id: s.matches(S.int),
+    chain_id: s.matches(ChainId.schema),
     event_id: s.matches(S.bigint),
     event_name: s.matches(S.string),
     contract_name: s.matches(S.string),
@@ -598,7 +622,7 @@ module RawEvents = {
   let table = mkTable(
     "raw_events",
     ~fields=[
-      mkField("chain_id", Int32, ~fieldSchema=S.int),
+      mkField("chain_id", ChainId, ~fieldSchema=ChainId.schema),
       mkField("event_id", UInt64, ~fieldSchema=S.bigint),
       mkField("event_name", String, ~fieldSchema=S.string),
       mkField("contract_name", String, ~fieldSchema=S.string),

package/src/db/InternalTable.res.mjs

@@ -4,6 +4,7 @@ import * as Table from "./Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Config from "../Config.res.mjs";
 import * as Address from "../Address.res.mjs";
+import * as ChainId from "../ChainId.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -25,7 +26,7 @@ let fields = [
 ];
 
 let table = Table.mkTable("envio_chains", undefined, [
-  Table.mkField("id", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("id", "ChainId", ChainId.schema, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("start_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("end_block", "Int32", S$RescriptSchema.$$null(S$RescriptSchema.int), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("max_reorg_depth", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -104,7 +105,8 @@ WHERE "` + "id" + `" = $1;`;
 function makeSetReadyAtQuery(pgSchema) {
   return `UPDATE "` + pgSchema + `"."` + table.tableName + `"
 SET "` + "ready_at" + `" = $1
-WHERE "` + "id" + `" = ANY($2::int[]);`;
+WHERE "` + "id" + `" = $2
+  AND "` + "ready_at" + `" IS NULL;`;
 }
 
 function makeGetInitialStateQuery(pgSchema) {
@@ -135,7 +137,7 @@ async function getInitialState(sql, pgSchema) {
   ]);
   let indexingAddressesByChainId = {};
   match[1].forEach(row => {
-    let key = row.chainId.toString();
+    let key = ChainId.toString(ChainId.normalizeOrThrow(row.chainId));
     let addresses = indexingAddressesByChainId[key];
     let addresses$1;
     if (addresses !== undefined) {
@@ -151,18 +153,21 @@ async function getInitialState(sql, pgSchema) {
       registrationBlock: row.registrationBlock
     });
   });
-  return match[0].map(rawInitialState => ({
-    id: rawInitialState.id,
-    startBlock: rawInitialState.startBlock,
-    endBlock: rawInitialState.endBlock,
-    maxReorgDepth: rawInitialState.maxReorgDepth,
-    firstEventBlockNumber: rawInitialState.firstEventBlockNumber,
-    timestampCaughtUpToHeadOrEndblock: rawInitialState.timestampCaughtUpToHeadOrEndblock,
-    numEventsProcessed: rawInitialState.numEventsProcessed,
-    progressBlockNumber: rawInitialState.progressBlockNumber,
-    indexingAddresses: Stdlib_Option.getOr(indexingAddressesByChainId[rawInitialState.id.toString()], []),
-    sourceBlockNumber: rawInitialState.sourceBlockNumber
-  }));
+  return match[0].map(rawInitialState => {
+    let id = ChainId.normalizeOrThrow(rawInitialState.id);
+    return {
+      id: id,
+      startBlock: rawInitialState.startBlock,
+      endBlock: rawInitialState.endBlock,
+      maxReorgDepth: rawInitialState.maxReorgDepth,
+      firstEventBlockNumber: rawInitialState.firstEventBlockNumber,
+      timestampCaughtUpToHeadOrEndblock: rawInitialState.timestampCaughtUpToHeadOrEndblock,
+      numEventsProcessed: rawInitialState.numEventsProcessed,
+      progressBlockNumber: rawInitialState.progressBlockNumber,
+      indexingAddresses: Stdlib_Option.getOr(indexingAddressesByChainId[ChainId.toString(id)], []),
+      sourceBlockNumber: rawInitialState.sourceBlockNumber
+    };
+  });
 }
 
 let progressFields = [
@@ -269,7 +274,7 @@ let EnvioInfo = {
 
 let dbSchema = S$RescriptSchema.object(s => ({
   id: s.f("id", Utils.$$BigInt.schema),
-  chain_id: s.f("chain_id", S$RescriptSchema.int),
+  chain_id: s.f("chain_id", ChainId.schema),
   block_number: s.f("block_number", S$RescriptSchema.int),
   block_hash: s.f("block_hash", S$RescriptSchema.union([
     S$RescriptSchema.string,
@@ -280,7 +285,7 @@ let dbSchema = S$RescriptSchema.object(s => ({
 
 let table$2 = Table.mkTable("envio_checkpoints", undefined, [
   Table.mkField("id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("chain_id", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("block_number", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("block_hash", "String", S$RescriptSchema.$$null(S$RescriptSchema.string), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("events_processed", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
@@ -311,13 +316,16 @@ function makeCommitedCheckpointIdQuery(pgSchema) {
   return `SELECT COALESCE(MAX(` + "id" + `), ` + (0n).toString() + `) AS id FROM "` + pgSchema + `"."` + table$2.tableName + `";`;
 }
 
-function makeInsertCheckpointQuery(pgSchema) {
+function makeInsertCheckpointQuery(pgSchema, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+  let chainIdArrayType = Table.getPgFieldType("ChainId", pgSchema, true, false, false, chainIdMode);
   return `INSERT INTO "` + pgSchema + `"."` + table$2.tableName + `" ("` + "id" + `", "` + "chain_id" + `", "` + "block_number" + `", "` + "block_hash" + `", "` + "events_processed" + `")
-SELECT * FROM unnest($1::` + "BIGINT" + `[],$2::` + "INTEGER" + `[],$3::` + "INTEGER" + `[],$4::` + "TEXT" + `[],$5::` + "INTEGER" + `[]);`;
+SELECT * FROM unnest($1::` + "BIGINT" + `[],$2::` + chainIdArrayType + `,$3::` + "INTEGER" + `[],$4::` + "TEXT" + `[],$5::` + "INTEGER" + `[]);`;
 }
 
-function insert(sql, pgSchema, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointBlockHashes, checkpointEventsProcessed) {
-  let query = makeInsertCheckpointQuery(pgSchema);
+function insert(sql, pgSchema, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointBlockHashes, checkpointEventsProcessed, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+  let query = makeInsertCheckpointQuery(pgSchema, chainIdMode);
   let checkpointIdStrings = Utils.$$BigInt.arrayToStringArray(checkpointIds);
   return sql.unsafe(query, [
     checkpointIdStrings,
@@ -359,7 +367,7 @@ function getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValid
 
 function makeGetRollbackProgressDiffQuery(pgSchema) {
   return `SELECT 
-  "` + "chain_id" + `",
+  "` + "chain_id" + `"::float8 as "` + "chain_id" + `",
   SUM("` + "events_processed" + `") as events_processed_diff,
   MIN("` + "block_number" + `") - 1 as new_progress_block_number
 FROM "` + pgSchema + `"."` + table$2.tableName + `"
@@ -389,7 +397,7 @@ let Checkpoints = {
 };
 
 let schema = S$RescriptSchema.schema(s => ({
-  chain_id: s.m(S$RescriptSchema.int),
+  chain_id: s.m(ChainId.schema),
   event_id: s.m(S$RescriptSchema.bigint),
   event_name: s.m(S$RescriptSchema.string),
   contract_name: s.m(S$RescriptSchema.string),
@@ -404,7 +412,7 @@ let schema = S$RescriptSchema.schema(s => ({
 }));
 
 let table$3 = Table.mkTable("raw_events", undefined, [
-  Table.mkField("chain_id", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("event_id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("event_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),

package/src/db/Table.res

@@ -23,6 +23,9 @@ type fieldType =
   | UInt52
   | UInt64
   | Int32
+  // Resolved to Int32 or UInt64 storage from the config's `ChainId.mode`, so
+  // the internal tables can stay module-level constants.
+  | ChainId
   | Number
   | BigInt({precision?: int})
   | BigDecimal({config?: (int, int)}) // (precision, scale)
@@ -138,11 +141,17 @@ let getPgFieldType = (
   ~isArray,
   ~isNumericArrayAsText,
   ~isNullable,
+  ~chainIdMode: ChainId.mode=Int32,
 ) => {
   let columnType = switch fieldType {
   | String => (Postgres.Text :> string)
   | Boolean => (Postgres.Boolean :> string)
   | Int32 => (Postgres.Integer :> string)
+  | ChainId =>
+    switch chainIdMode {
+    | Int32 => (Postgres.Integer :> string)
+    | Int64 => (Postgres.BigInt :> string)
+    }
   | Uint32 => (Postgres.BigInt :> string)
   | UInt52 => (Postgres.BigInt :> string)
   | UInt64 => (Postgres.BigInt :> string)
@@ -378,7 +387,7 @@ type sqlParams<'entity> = {
   hasArrayField: bool,
 }
 
-let toSqlParams = (table: table, ~schema, ~pgSchema) => {
+let toSqlParams = (table: table, ~schema, ~pgSchema, ~chainIdMode: ChainId.mode=Int32) => {
   let quotedFieldNames = []
   let quotedNonPrimaryFieldNames = []
   let arrayFieldTypes = []
@@ -441,6 +450,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
               ~isArray=true,
               ~isNullable=f.isNullable,
               ~isNumericArrayAsText=false,
+              ~chainIdMode,
             )
             switch f.fieldType {
             | Enum(_) => `${(Text: Postgres.columnType :> string)}[]::${pgFieldType}`

package/src/db/Table.res.mjs

@@ -96,7 +96,8 @@ function getPgFieldName(fieldOrDerived) {
 
 let idFieldName = "id";
 
-function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNullable) {
+function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNullable, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let columnType;
   if (typeof fieldType !== "object") {
     switch (fieldType) {
@@ -109,6 +110,9 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
       case "Int32" :
         columnType = "INTEGER";
         break;
+      case "ChainId" :
+        columnType = chainIdMode === "int32" ? "INTEGER" : "BIGINT";
+        break;
       case "Number" :
         columnType = "DOUBLE PRECISION";
         break;
@@ -247,7 +251,7 @@ function getIdFieldOrThrow(table) {
 }
 
 function getIdPgFieldType(table, pgSchema) {
-  return getPgFieldType(getIdFieldOrThrow(table).fieldType, pgSchema, false, false, false);
+  return getPgFieldType(getIdFieldOrThrow(table).fieldType, pgSchema, false, false, false, undefined);
 }
 
 function getIdSchema(table) {
@@ -324,7 +328,8 @@ function getUnfilteredCompositeIndexesUnsafe(table) {
   }));
 }
 
-function toSqlParams(table, schema, pgSchema) {
+function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let quotedFieldNames = [];
   let quotedNonPrimaryFieldNames = [];
   let arrayFieldTypes = [];
@@ -395,7 +400,7 @@ function toSqlParams(table, schema, pgSchema) {
       let tmp;
       if (field$1.TAG === "Field") {
         let f = field$1._0;
-        let pgFieldType = getPgFieldType(f.fieldType, pgSchema, true, false, f.isNullable);
+        let pgFieldType = getPgFieldType(f.fieldType, pgSchema, true, false, f.isNullable, chainIdMode);
         let match = f.fieldType;
         tmp = typeof match !== "object" ? (
             match === "Boolean" ? "INTEGER" + `[]::` + pgFieldType : pgFieldType

package/src/sources/AddressSet.res

@@ -15,10 +15,11 @@ type startBlockGroup = {startBlock: int, count: int}
 // fetch state can size and split partitions without ever walking the addresses.
 @send external countFor: (t, string) => int = "countFor"
 
-// The chain-wide address gate, reachable through any set of the store. Not set
-// membership: the simulate source has no native query boundary, so it applies
-// the same gate every real source applies while routing.
-@send external has: (t, Address.t, string, int) => bool = "has"
+// This set holds the address under the contract and it has already started at
+// the block — the gate a real source's router applies to a server-side
+// address-filtered query. The temporal half still comes from the store: a
+// merged partition's addresses don't all start at the same block.
+@send external containsAt: (t, Address.t, string, int) => bool = "containsAt"
 
 @send external contractNames: t => array<string> = "contractNames"
 

package/src/sources/AddressStore.res

@@ -67,28 +67,39 @@ let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array
 }
 
 // The contracts of a chain that have events, with the earliest block any of
-// their events may fire at.
+// their events may fire at. `None` means unrestricted, so it wins over any
+// `Some`: one registration without a start block makes the whole contract's
+// address gate open from the chain's start, and the per-registration start
+// block still holds back the registrations that declared one.
 let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>): array<contract> => {
-  let startBlocks = Dict.make()
+  // Only ever holds a declared start block, so a missing key is unambiguous —
+  // storing `None` in a dict would be indistinguishable from "not seen yet".
+  let startBlocks: dict<int> = Dict.make()
+  let unrestricted = Utils.Set.make()
   let names = []
   onEventRegistrations->Array.forEach(reg => {
     let name = reg.eventConfig.contractName
-    switch startBlocks->Utils.Dict.dangerouslyGetNonOption(name) {
-    | None =>
+    if !(names->Array.includes(name)) {
       names->Array.push(name)->ignore
-      startBlocks->Dict.set(name, reg.startBlock)
-    | Some(existing) =>
+    }
+    switch reg.startBlock {
+    | None => unrestricted->Utils.Set.add(name)->ignore
+    | Some(startBlock) =>
       startBlocks->Dict.set(
         name,
-        switch (existing, reg.startBlock) {
-        | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
-        | (Some(_) as s, None) | (None, Some(_) as s) => s
-        | (None, None) => None
+        switch startBlocks->Utils.Dict.dangerouslyGetNonOption(name) {
+        | Some(existing) => Pervasives.min(existing, startBlock)
+        | None => startBlock
         },
       )
     }
   })
-  names->Array.map(name => {name, startBlock: startBlocks->Dict.getUnsafe(name)})
+  names->Array.map(name => {
+    name,
+    startBlock: unrestricted->Utils.Set.has(name)
+      ? None
+      : startBlocks->Utils.Dict.dangerouslyGetNonOption(name),
+  })
 }
 
 @send external nextId: t => int = "nextId"
@@ -108,9 +119,9 @@ external startBlockGroups: (t, string) => array<AddressSet.startBlockGroup> = "s
 @send external contractCount: (t, string) => int = "contractCount"
 @send external size: t => int = "size"
 
-// The gate routing applies, exposed for the simulate source — it has no real
-// query boundary to gate at.
-@send external has: (t, Address.t, string, int) => bool = "has"
+// The chain-wide gate routing applies, exposed for the simulate source — it has
+// no real query boundary to gate at.
+@send external isIndexedAt: (t, Address.t, string, int) => bool = "isIndexedAt"
 
 // Drops every address registered after the target block, returning how many
 // were dropped. Ids are tombstoned rather than reused, so sets built before the