envio 3.13.0 → 3.14.0-subgraph

package/src/UserContext.res.mjs

@@ -1,19 +1,83 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as LoadLayer from "./LoadLayer.res.mjs";
+import * as SyncWrites from "./SyncWrites.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
-import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let Suspend = /* @__PURE__ */Primitive_exceptions.create("UserContext.Suspend");
+
+function isSuspend(exn) {
+  return exn.RE_EXN_ID === Suspend;
+}
+
+function makeSyncState() {
+  return {
+    status: "Active",
+    pending: undefined,
+    memo: undefined,
+    writes: undefined
+  };
+}
+
+function getPending(sync) {
+  let pending = sync.pending;
+  if (pending !== undefined) {
+    return pending;
+  }
+  let pending$1 = [];
+  sync.pending = pending$1;
+  return pending$1;
+}
+
+function getMemo(sync) {
+  let memo = sync.memo;
+  if (memo !== undefined) {
+    return memo;
+  }
+  let memo$1 = {};
+  sync.memo = memo$1;
+  return memo$1;
+}
+
+function checkStatusOrThrow(params, access) {
+  let exn = params.sync.status;
+  if (typeof exn !== "object") {
+    if (exn === "Active") {
+      return;
+    } else {
+      return ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access ` + access + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+    }
+  }
+  throw exn._0;
+}
+
+function scheduleAndSuspend(params, promise) {
+  getPending(params.sync).push(promise);
+  params.sync.status = {
+    TAG: "Aborted",
+    _0: {
+      RE_EXN_ID: Suspend
+    }
+  };
+  throw {
+    RE_EXN_ID: Suspend,
+    Error: new Error()
+  };
+}
 
 let paramsByThis = new WeakMap();
 
@@ -47,29 +111,71 @@ var EffectContext = function(params, chainId, effectName, defaultShouldCache, ca
 EffectContext.prototype = effectContextPrototype;
 ;
 
-function initEffect(params) {
-  let handlerChainId = Internal.getItemChainId(params.item);
+function prepareEffectCall(params, effect, input, caller) {
   let isCrossChain = effect => Stdlib_Option.getOr(effect.crossChain, params.config.defaultCrossChain);
-  let makeCaller = caller => ((effect, input) => {
-    let scope = isCrossChain(effect) ? "crossChain" : handlerChainId;
-    if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
-      Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
+  let scope = isCrossChain(effect) ? "crossChain" : Internal.getItemChainId(params.item);
+  if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
+    Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
+  }
+  let tmp;
+  tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
+  let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, (nested, nestedInput) => callEffectAsync(params, nested, nestedInput, effect));
+  let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+  let effectArgs_chainId = Internal.getItemChainId(params.item);
+  let effectArgs_checkpointId = params.checkpointId;
+  let effectArgs = {
+    input: input,
+    context: effectContext,
+    cacheKey: effectArgs_cacheKey,
+    chainId: effectArgs_chainId,
+    checkpointId: effectArgs_checkpointId
+  };
+  return [
+    scope,
+    effectArgs
+  ];
+}
+
+function callEffectAsync(params, effect, input, caller) {
+  let match = prepareEffectCall(params, effect, input, caller);
+  return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, match[1], match[0], params.indexerState, params.isPreload, params.item, params.config.ecosystem);
+}
+
+function initEffect(params) {
+  return (effect, input) => {
+    checkStatusOrThrow(params, "context.effect");
+    return callEffectAsync(params, effect, input, undefined);
+  };
+}
+
+function effectMemoKey(effect, scope, cacheKey) {
+  if (scope === "crossChain") {
+    return effect.name + `.` + cacheKey;
+  } else {
+    return effect.name + `.` + ChainId.toString(scope) + `.` + cacheKey;
+  }
+}
+
+function initEffectSync(params) {
+  return (effect, input) => {
+    checkStatusOrThrow(params, "context.effectSync");
+    let match = prepareEffectCall(params, effect, input, undefined);
+    let effectArgs = match[1];
+    let scope = match[0];
+    let memo = getMemo(params.sync);
+    let memoKey = effectMemoKey(effect, scope, effectArgs.cacheKey);
+    let output = memo[memoKey];
+    if (output !== undefined) {
+      return Primitive_option.valFromOption(output);
     }
-    let tmp;
-    tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
-    let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, makeCaller(effect));
-    let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
-    let effectArgs_checkpointId = params.checkpointId;
-    let effectArgs = {
-      input: input,
-      context: effectContext,
-      cacheKey: effectArgs_cacheKey,
-      chainId: handlerChainId,
-      checkpointId: effectArgs_checkpointId
-    };
-    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
-  });
-  return makeCaller(undefined);
+    let inMemTable = InMemoryStore.getEffectInMemTable(params.indexerState, effect, scope);
+    if (!InMemoryStore.hasEffectOutput(inMemTable, effectArgs.cacheKey)) {
+      return scheduleAndSuspend(params, LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem));
+    }
+    let output$1 = InMemoryStore.getEffectOutputUnsafe(inMemTable, effectArgs.cacheKey);
+    memo[memoKey] = output$1;
+    return output$1;
+  };
 }
 
 function entityScope(params) {
@@ -92,26 +198,88 @@ function throwClickHouseReadOnly(entityConfig, op) {
   return Stdlib_JsError.throwWithMessage(`context.` + entityConfig.name + `.` + op + `() is unavailable: ClickHouse storage is currently write-only. Follow Envio releases to be notified when ClickHouse supports both reads and writes from handlers.`);
 }
 
+function writeChange(params, change) {
+  let scope = entityScope(params);
+  let writes = params.sync.writes;
+  if (writes !== undefined) {
+    return SyncWrites.record(writes, params.entityConfig, scope, change);
+  } else {
+    return SyncWrites.write(params.indexerState, params.entityConfig, scope, change);
+  }
+}
+
+function getRoundWrite(params, entityId) {
+  let writes = params.sync.writes;
+  if (writes !== undefined) {
+    return SyncWrites.getById(writes, params.entityConfig, entityId);
+  }
+}
+
+function getSyncHandler(params, entityId) {
+  let entity = getRoundWrite(params, entityId);
+  if (entity !== undefined) {
+    return Primitive_option.valFromOption(entity);
+  }
+  let entity$1 = LoadLayer.getByIdInMemory(params.entityConfig, entityScope(params), params.indexerState, entityId);
+  if (entity$1 !== undefined) {
+    return Primitive_option.valFromOption(entity$1);
+  } else {
+    return scheduleAndSuspend(params, LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId));
+  }
+}
+
+function getWhereSyncHandler(params, filter) {
+  let entityConfig = params.entityConfig;
+  let filter$1 = EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table);
+  let entities = LoadLayer.getByFilterInMemory(entityConfig, entityScope(params), params.indexerState, filter$1);
+  if (entities === undefined) {
+    return scheduleAndSuspend(params, LoadLayer.loadByParsedFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter$1));
+  }
+  let writes = params.sync.writes;
+  if (writes !== undefined) {
+    return SyncWrites.overlayFilter(writes, entities, entityConfig, filter$1);
+  } else {
+    return entities;
+  }
+}
+
+function getInBlockSyncHandler(params, entityId) {
+  let entity = getRoundWrite(params, entityId);
+  if (entity !== undefined) {
+    return Primitive_option.valFromOption(entity);
+  }
+  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params));
+  let change = inMemTable.latestEntityChangeById[entityId];
+  if (change !== undefined && change.checkpointId === params.checkpointId) {
+    return InMemoryTable.Entity.mapChangeToEntity(change);
+  }
+}
+
 let entityTraps_get = (params, prop) => {
+  checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.` + prop);
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let scope = entityScope(params);
-  let committedCheckpointId = IndexerState.committedCheckpointIdFor(params.indexerState, scope);
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
-      type: "SET",
-      entityId: entity.id,
-      entity: entity,
-      checkpointId: params.checkpointId
-    });
+  let set = params.isPreload ? noopSet : entity => {
+      checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.set`);
+      writeChange(params, {
+        type: "SET",
+        entityId: entity.id,
+        entity: entity,
+        checkpointId: params.checkpointId
+      });
+    };
   switch (prop) {
     case "deleteUnsafe" :
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
-          type: "DELETE",
-          entityId: entityId,
-          checkpointId: params.checkpointId
-        });
+        return entityId => {
+          checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.deleteUnsafe`);
+          writeChange(params, {
+            type: "DELETE",
+            entityId: entityId,
+            checkpointId: params.checkpointId
+          });
+        };
       }
     case "get" :
       if (isClickHouseOnly) {
@@ -119,6 +287,8 @@ let entityTraps_get = (params, prop) => {
       } else {
         return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
+    case "getInBlockSync" :
+      return entityId => getInBlockSyncHandler(params, entityId);
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
@@ -144,12 +314,16 @@ let entityTraps_get = (params, prop) => {
           }
         });
       }
+    case "getSync" :
+      return entityId => getSyncHandler(params, entityId);
     case "getWhere" :
       if (isClickHouseOnly) {
         return _filter => throwClickHouseReadOnly(params.entityConfig, "getWhere");
       } else {
         return filter => getWhereHandler(params, filter);
       }
+    case "getWhereSync" :
+      return filter => getWhereSyncHandler(params, filter);
     case "set" :
       return set;
     default:
@@ -161,16 +335,78 @@ let entityTraps = {
   get: entityTraps_get
 };
 
-let handlerTraps_get = (params, prop) => {
-  if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+async function runSyncRound(params, fn, round) {
+  if (round > 10000) {
+    Stdlib_JsError.throwWithMessage(`The handler suspended on a synchronous read too many times: gave up after ` + (10000).toString() + ` rounds. This usually means the code isn't deterministic across reruns.`);
+  }
+  params.sync.status = "Active";
+  params.sync.pending = undefined;
+  let writes = SyncWrites.make();
+  params.sync.writes = writes;
+  let suspended;
+  let exit = 0;
+  let val;
+  try {
+    val = fn();
+    exit = 1;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    params.sync.writes = undefined;
+    if (exn.RE_EXN_ID === Suspend) {
+      suspended = true;
+    } else {
+      let pending = params.sync.pending;
+      if (pending !== undefined) {
+        params.sync.pending = undefined;
+        pending.forEach(promise => {
+          Utils.$$Promise.silentCatch(promise);
+        });
+      }
+      throw exn;
+    }
+  }
+  if (exit === 1) {
+    params.sync.writes = undefined;
+    let match = params.sync.status;
+    if (typeof match !== "object") {
+      if (match === "Active") {
+        SyncWrites.commit(writes, params.indexerState);
+        suspended = false;
+      } else {
+        SyncWrites.commit(writes, params.indexerState);
+        suspended = false;
+      }
+    } else {
+      suspended = true;
+    }
+  }
+  if (!suspended) {
+    return;
+  }
+  let pending$1 = Stdlib_Option.getOr(params.sync.pending, []);
+  params.sync.pending = undefined;
+  let errors = [];
+  await Promise.all(pending$1.map(promise => Stdlib_Promise.$$catch(promise, exn => {
+    errors.push(exn);
+    return Promise.resolve();
+  })));
+  let exn$1 = errors[0];
+  if (exn$1 !== undefined) {
+    throw exn$1;
   }
+  return await runSyncRound(params, fn, round + 1 | 0);
+}
+
+let handlerTraps_get = (params, prop) => {
+  checkStatusOrThrow(params, `context.` + prop);
   switch (prop) {
     case "chain" :
       let chainId = Internal.getItemChainId(params.item);
       return params.chains[chainId];
     case "effect" :
       return initEffect(params);
+    case "effectSync" :
+      return initEffectSync(params);
     case "isPreload" :
       return params.isPreload;
     case "log" :
@@ -179,6 +415,8 @@ let handlerTraps_get = (params, prop) => {
       } else {
         return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
       }
+    case "runSync" :
+      return fn => runSyncRound(params, fn, 1);
     default:
       let entityConfig = params.config.userEntitiesByName[prop];
       if (entityConfig !== undefined) {
@@ -191,7 +429,7 @@ let handlerTraps_get = (params, prop) => {
           isPreload: params.isPreload,
           chains: params.chains,
           config: params.config,
-          isResolved: params.isResolved,
+          sync: params.sync,
           entityConfig: entityConfig
         }, entityTraps);
       } else {
@@ -208,16 +446,36 @@ function getHandlerContext(params) {
   return new Proxy(params, handlerTraps);
 }
 
+let maxSyncRounds = 10000;
+
 export {
+  Suspend,
+  isSuspend,
+  makeSyncState,
+  getPending,
+  getMemo,
+  checkStatusOrThrow,
+  scheduleAndSuspend,
   paramsByThis,
   effectContextPrototype,
+  prepareEffectCall,
+  callEffectAsync,
   initEffect,
+  effectMemoKey,
+  initEffectSync,
   entityScope,
   getWhereHandler,
   noopSet,
   noopDeleteUnsafe,
   throwClickHouseReadOnly,
+  writeChange,
+  getRoundWrite,
+  getSyncHandler,
+  getWhereSyncHandler,
+  getInBlockSyncHandler,
   entityTraps,
+  maxSyncRounds,
+  runSyncRound,
   handlerTraps,
   getHandlerContext,
 }

package/src/Utils.res

@@ -10,14 +10,6 @@ external toMethod: 'a => 'a = "%unsafe_to_method"
 
 @val external importPath: string => promise<unknown> = "import"
 
-@val
-external importPathWithJson: (
-  string,
-  @as(json`{with: {type: "json"}}`) _,
-) => promise<{
-  "default": JSON.t,
-}> = "import"
-
 // Half the delay fixed, half spread across it. Every indexer pointed at one
 // provider loses its stream, or gives up on a quiet chain, in the same instant
 // that provider blinks, and putting them all back on the same schedule is how a

package/src/Worker.res

@@ -82,6 +82,14 @@ let bindToSupervisor = () => {
 
 %%private(let send = (message: workerMessage) => NodeJs.Process.sendToParent(message)->ignore)
 
+// A worker done with its chains exits only once its final snapshot is on the
+// channel: the last periodic one can be up to an interval old, and the
+// supervisor would go on reporting those chains as it left them.
+let exitAfterReporting = (~metrics: Metrics.t) =>
+  NodeJs.Process.sendToParentThen(Snapshot({metrics, runtime: Metrics.sampleRuntime()}), () =>
+    NodeJs.process->NodeJs.exitWithCode(Success)
+  )->ignore
+
 // Reports this process's chains and its own runtime for as long as it runs, so
 // the supervisor can merge every worker's into the one snapshot the run serves,
 // and listens for the one decision the supervisor makes on the run's behalf.

package/src/Worker.res.mjs

@@ -51,6 +51,16 @@ function bindToSupervisor() {
   });
 }
 
+function exitAfterReporting(metrics) {
+  process.send({
+    kind: "snapshot",
+    metrics: metrics,
+    runtime: Metrics.sampleRuntime()
+  }, () => {
+    Process.exit(0);
+  });
+}
+
 function bindRun(getMetrics, onReleaseRealtime) {
   if (isEnabled) {
     Metrics.startRuntimeCollectors();
@@ -76,6 +86,7 @@ export {
   config,
   isEnabled,
   bindToSupervisor,
+  exitAfterReporting,
   bindRun,
 }
 /* configSchema Not a pure module */

package/src/bindings/NodeJs.res

@@ -69,9 +69,17 @@ module Process = {
   // `process` rather than off a namespace import, which would drop the
   // receiver Node's own implementations read.
   @val @scope("process") external sendToParent: 'msg => bool = "send"
+  // The callback runs once the message is handed to the channel.
+  @val @scope("process") external sendToParentThen: ('msg, unit => unit) => bool = "send"
   @val @scope("process")
   external onMessage: (@as("message") _, 'msg => unit) => unit = "on"
   @val @scope("process") external onSignal: (string, unit => unit) => unit = "on"
+  @val @scope("process") external offSignal: (string, unit => unit) => unit = "removeListener"
+  @val @scope("process") external listenerCount: string => int = "listenerCount"
+  @val @scope("process") external pid: int = "pid"
+  @val @scope("process") external kill: (int, string) => bool = "kill"
+  @val @scope("process")
+  external onExit: (@as("exit") _, unit => unit) => unit = "on"
   // Present only in a process forked with an IPC channel.
   @val @scope("process") external channel: Nullable.t<unknown> = "channel"
   @val @scope("process")
@@ -205,17 +213,10 @@ module Url = {
 module ImportMeta = {
   type t = {url: Url.t}
   @val external importMeta: t = "import.meta"
-  // Get import.meta.url as string for module registration
-  @val external url: string = "import.meta.url"
   // Resolve module specifier to file:// URL
   @val external resolve: string => string = "import.meta.resolve"
 }
 
-module Module = {
-  // Register ESM loader hooks (e.g., for TypeScript support via tsx)
-  @module("node:module") external register: (string, string) => unit = "register"
-}
-
 module Path = {
   type t
 

package/src/bindings/NodeJs.res.mjs

@@ -41,8 +41,6 @@ let Url$1 = {};
 
 let ImportMeta = {};
 
-let Module = {};
-
 function getDirname(importMeta) {
   return Path.dirname(Url.fileURLToPath(importMeta.url));
 }
@@ -68,7 +66,6 @@ export {
   ChildProcess,
   Url$1 as Url,
   ImportMeta,
-  Module,
   Path$1 as Path,
   WorkerThreads,
   Fs,

package/src/bindings/Pino.res

@@ -113,8 +113,8 @@ module ECS = {
 }
 
 /**
-Jank solution to make logs use console log wrather than stream.write so that ink 
-can render the logs statically.
+Logs through `console.log` rather than `stream.write`, so that the TUI can print
+them above its frame.
 */
 module MultiStreamLogger = {
   type stream = {write: string => unit}

package/src/db/InternalTable.res

@@ -159,12 +159,14 @@ WHERE "${table.tableName}"."chain_id" = dead.chain_id
     ->Utils.Promise.ignoreValue
   }
 
-  let makeGetRowsQuery = (~pgSchema) =>
+  let makeGetRowsQuery = (~pgSchema, ~onlyConfig=false) =>
     `SELECT "chain_id" as "chainId",
 "address" as "address",
 "contract_id" as "contractId",
 "registration_block" as "registrationBlock"
-FROM "${pgSchema}"."${table.tableName}";`
+FROM "${pgSchema}"."${table.tableName}"${onlyConfig
+        ? ` WHERE "registration_block" = ${AddressRows.configRegistrationBlock->Int.toString}`
+        : ""};`
 }
 
 module Chains = {
@@ -391,6 +393,54 @@ WHERE "${(#id: field :> string)}" = $2
     checkpointId: string,
   }
 
+  let readStoredChains = async (sql, ~pgSchema): array<ResumePlan.storedChain> => {
+    let (rows, configAddressRows) = await Promise.all2((
+      sql
+      ->Postgres.unsafe(
+        `SELECT "${(#id: field :> string)}" as "id",
+"${(#ecosystem: field :> string)}" as "ecosystem",
+"${(#start_block: field :> string)}" as "startBlock",
+"${(#end_block: field :> string)}" as "endBlock",
+"${(#max_reorg_depth: field :> string)}" as "maxReorgDepth"
+FROM "${pgSchema}"."${table.tableName}";`,
+      )
+      ->(
+        Utils.magic: promise<array<unknown>> => promise<
+          array<{
+            "id": ChainId.t,
+            "ecosystem": string,
+            "startBlock": int,
+            "endBlock": Null.t<int>,
+            "maxReorgDepth": int,
+          }>,
+        >
+      ),
+      sql
+      ->Postgres.unsafe(EnvioAddresses.makeGetRowsQuery(~pgSchema, ~onlyConfig=true))
+      ->(Utils.magic: promise<array<unknown>> => promise<array<AddressRows.row>>),
+    ))
+    let configAddressesByChain = Dict.make()
+    configAddressRows->Array.forEach(addressRow =>
+      configAddressesByChain->Utils.Dict.push(
+        addressRow.chainId->ChainId.normalizeOrThrow->ChainId.toString,
+        addressRow,
+      )
+    )
+    rows->Array.map((row): ResumePlan.storedChain => {
+      let id = row["id"]->ChainId.normalizeOrThrow
+      {
+        id,
+        ecosystem: row["ecosystem"],
+        startBlock: row["startBlock"],
+        endBlock: row["endBlock"]->Null.toOption,
+        maxReorgDepth: row["maxReorgDepth"],
+        configAddresses: configAddressesByChain
+        ->Utils.Dict.dangerouslyGetNonOption(id->ChainId.toString)
+        ->Option.getOr([]),
+      }
+    })
+  }
+
   let makeGetInitialStateQuery = (~pgSchema) => {
     `SELECT "${(#id: field :> string)}" as "id",
 "${(#start_block: field :> string)}" as "startBlock",