envio 3.14.0-subgraph → 3.14.1

package/src/sources/RpcSource.res.mjs

@@ -93,6 +93,14 @@ function make(param) {
           },
           Error: new Error()
         };
+      case "BehindHead" :
+        let blockNumber$1 = result.blockNumber;
+        throw {
+          RE_EXN_ID: Source.SourceBehindHead,
+          blockNumber: blockNumber$1 !== undefined ? blockNumber$1 : missing("blockNumber"),
+          requestStats: result.requestStats,
+          Error: new Error()
+        };
     }
     let parsingTimeRef = Performance.now();
     let parsedQueueItems = EvmEventItem.toInternalItems(result.items, onEventRegistrations, chainId);
@@ -114,12 +122,22 @@ function make(param) {
   let getBlockHashes = async (blockNumbers, param) => {
     let match = await rpcClient.getBlockHashes(blockNumbers);
     let result = match[0];
-    let message = result.message;
+    let match$1 = result.message;
+    let match$2 = result.behindHeadBlock;
     return {
-      result: message !== undefined ? ({
-          TAG: "Error",
-          _0: Primitive_exceptions.internalToException(new Error(message))
-        }) : ({
+      result: match$1 !== undefined ? (
+          match$2 !== undefined ? ({
+              TAG: "Error",
+              _0: {
+                RE_EXN_ID: Source.SourceBehindHead,
+                blockNumber: match$2,
+                requestStats: result.requestStats
+              }
+            }) : ({
+              TAG: "Error",
+              _0: Primitive_exceptions.internalToException(new Error(match$1))
+            })
+        ) : ({
           TAG: "Ok",
           _0: match[1]
         }),

package/src/sources/SourceManager.res

@@ -24,7 +24,7 @@ let recordStatsInto = (
   aggregates: dict<requestStatAgg>,
   requestStats: array<Source.requestStat>,
 ) => {
-  requestStats->Array.forEach(({method, seconds, responseBlocks: ?responseBlocks}) => {
+  requestStats->Array.forEach(({method, seconds, ?responseBlocks}) => {
     let agg = switch aggregates->Utils.Dict.dangerouslyGetNonOption(method) {
     | Some(agg) => agg
     | None =>
@@ -577,11 +577,14 @@ let backoffBeforeRetry = async (
   ~isRealtime,
   ~backoffMillis,
   ~minBackoffMillis=0,
+  ~failoverAfterRetries=2,
   ~excludedSources=?,
 ) => {
-  // Give the source two attempts before demoting it, then re-try a failover
+  // Give the source a few attempts before demoting it, then re-try a failover
   // every second attempt.
-  let switchedToWorkingSource = if retry >= 2 && retry->mod(2) === 0 {
+  let switchedToWorkingSource = if (
+    retry >= failoverAfterRetries && (retry - failoverAfterRetries)->mod(2) === 0
+  ) {
     let now = Date.now()
     sourceState.lastFailedAt = Some(now)
     switch sourceManager->getNextSource(~isRealtime, ~excludedSources?) {
@@ -608,6 +611,25 @@ let backoffBeforeRetry = async (
   }
 }
 
+// A replica behind its siblings usually catches up within seconds, and failing
+// over demotes an otherwise healthy source for the whole recovery timeout. So
+// the source keeps the query for about 10s (100ms doubling, capped at 1s per
+// attempt) before a failover is tried. Past that window the source is behind
+// for real, and with nowhere to fail over to it is polled less and less often,
+// doubling from 1s up to the shared cap.
+let behindHeadFailoverRetries = 12
+
+let behindHeadBackoffMillis = retry =>
+  if retry < behindHeadFailoverRetries {
+    Utils.expBackoff(~base=100, ~exp=retry, ~maxMillis=1_000)
+  } else {
+    Utils.expBackoff(
+      ~base=1_000,
+      ~exp=retry - behindHeadFailoverRetries,
+      ~maxMillis=maxRetryBackoffMillis,
+    )
+  }
+
 // The queried block hasn't reached the backend instance that served the
 // request. Expected around the head of a load-balanced backend, so early
 // attempts stay quiet and short; a source that stays behind fails over like any
@@ -619,18 +641,28 @@ let retryBehindHead = async (
   ~isRealtime,
   ~logger: Pino.t,
   ~blockNumber: int,
-  ~method: string,
-  ~err: exn,
   ~excludedSources=?,
 ) => {
-  let backoffMillis = retry->retryBackoffMillis
-  let log = retry >= 4 ? Logging.childWarn : Logging.childTrace
+  let backoffMillis = retry->behindHeadBackoffMillis
+  let source = sourceState.source.name
+  let block = blockNumber->Int.toString
+  // The condition is routine and resolves without the user doing anything, so
+  // the wording says so; the error object would only add internals.
+  let (log, msg) = if retry < behindHeadFailoverRetries {
+    (
+      Logging.childTrace,
+      `${source} hasn't reached block ${block} on all of its servers yet. This is normal near the latest block and resolves by itself - retrying shortly.`,
+    )
+  } else {
+    (
+      Logging.childWarn,
+      `${source} is still catching up to block ${block}. This is a delay on the provider's side; indexing will continue automatically, using another data source if one is configured.`,
+    )
+  }
   logger->log({
-    "msg": `Block #${blockNumber->Int.toString} is not available on the ${sourceState.source.name} source yet. Instances of a load-balanced backend drift slightly around the head, so this is expected - indexing continues after an automatic retry.`,
-    "method": method,
+    "msg": msg,
     "retry": retry,
     "backOffMilliseconds": backoffMillis,
-    "err": err->Utils.prettifyExn,
   })
   await sourceManager->backoffBeforeRetry(
     sourceState,
@@ -638,6 +670,7 @@ let retryBehindHead = async (
     ~isRealtime,
     ~backoffMillis,
     ~minBackoffMillis=minRecoverableBackoffMillis,
+    ~failoverAfterRetries=behindHeadFailoverRetries,
     ~excludedSources?,
   )
 }
@@ -861,8 +894,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
       // Re-armed because distrusting a stream is a one-shot — the next height it
       // delivers takes it back at its word — and the silence that earned it can
       // come straight back.
-      let rec armPokeTimeout = () =>
-        pokeTimeoutId := Some(setTimeout(() => {
+      let rec armPokeTimeout = () => pokeTimeoutId := Some(setTimeout(() => {
               pokeTimeoutId := None
               if !settled.contents {
                 watched->Array.forEach(subscription => subscription.distrustStream())
@@ -879,8 +911,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
       // operator about when they hear about a quiet chain, and spreading that
       // would report it early. Fires once — the warning is worth saying once per
       // wait, and a fallback stays recruited.
-      let armStallTimeout = () =>
-        stallTimeoutId := Some(setTimeout(() => {
+      let armStallTimeout = () => stallTimeoutId := Some(setTimeout(() => {
               stallTimeoutId := None
               if !settled.contents {
                 stalled := true
@@ -917,9 +948,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
                 }
 
                 // Recruited to poll, not to stream: see `watch`.
-                fallbackSources->Array.forEach(
-                  sourceState => sourceState->watch(~withStream=false),
-                )
+                fallbackSources->Array.forEach(sourceState => sourceState->watch(~withStream=false))
 
                 // A fallback recruited here can still be holding a stream from an
                 // earlier wait that made it a primary, and a live stream is not
@@ -940,7 +969,6 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
   })
 }
 
-
 let executeQuery = async (
   sourceManager: t,
   ~query: FetchState.query,
@@ -949,11 +977,12 @@ let executeQuery = async (
 ) => {
   // Read when the manager actually runs out of sources, not on the way in: the
   // reason is recorded by the failure that disabled the last one.
-  let noSourcesError = () => switch sourceManager.disableReason {
-  | Some(reason) =>
-    `The indexer doesn't have data-sources which can continue fetching. The last one was disabled because ${reason}`
-  | None => "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team."
-  }
+  let noSourcesError = () =>
+    switch sourceManager.disableReason {
+    | Some(reason) =>
+      `The indexer doesn't have data-sources which can continue fetching. The last one was disabled because ${reason}`
+    | None => "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team."
+    }
 
   // Sources where the query is impossible - lazily allocated, excluded for the duration of this query
   let excludedSourcesRef = ref(None)
@@ -1030,7 +1059,7 @@ let executeQuery = async (
       await sourceManager->waitForRateLimitReset(~resetMs, ~retry, ~logger)
       retryRef := retryRef.contents + 1
 
-    | Source.SourceBehindHead({blockNumber, requestStats}) as err =>
+    | Source.SourceBehindHead({blockNumber, requestStats}) =>
       sourceState->recordRequestStats(requestStats)
       await sourceManager->retryBehindHead(
         sourceState,
@@ -1038,8 +1067,6 @@ let executeQuery = async (
         ~isRealtime,
         ~logger,
         ~blockNumber,
-        ~method="getItems",
-        ~err,
         ~excludedSources=?excludedSourcesRef.contents,
       )
       retryRef := retryRef.contents + 1
@@ -1135,7 +1162,11 @@ let executeQuery = async (
         })
         retryRef := 0
 
-      | FailedGettingItems({?exn, attemptedToBlock, retry: WithBackoff({message, backoffMillis})}) =>
+      | FailedGettingItems({
+          ?exn,
+          attemptedToBlock,
+          retry: WithBackoff({message, backoffMillis}),
+        }) =>
         await sourceManager->retryFailedPage(
           sourceState,
           ~retry,
@@ -1200,22 +1231,14 @@ let getBlockHashes = async (sourceManager: t, ~blockNumbers: array<int>, ~isReal
       | Error(exn) => throw(exn)
       }
     } catch {
-    | Source.RateLimited({resetMs, requestStats}) =>
-      sourceState->recordRequestStats(requestStats)
+    // A failure arrives as `res.result`, whose `res.requestStats` is already
+    // recorded above, so the stats the error carries are not recorded again.
+    | Source.RateLimited({resetMs}) =>
       await sourceManager->waitForRateLimitReset(~resetMs, ~retry, ~logger)
       retryRef := retryRef.contents + 1
 
-    | Source.SourceBehindHead({blockNumber, requestStats}) as err =>
-      sourceState->recordRequestStats(requestStats)
-      await sourceManager->retryBehindHead(
-        sourceState,
-        ~retry,
-        ~isRealtime,
-        ~logger,
-        ~blockNumber,
-        ~method="getBlockHashes",
-        ~err,
-      )
+    | Source.SourceBehindHead({blockNumber}) =>
+      await sourceManager->retryBehindHead(sourceState, ~retry, ~isRealtime, ~logger, ~blockNumber)
       retryRef := retryRef.contents + 1
 
     | Source.InconsistentResponse(_) as err =>

package/src/sources/SourceManager.res.mjs

@@ -470,10 +470,11 @@ function getNextSource(sourceManager, isRealtime, excludedSources) {
   }
 }
 
-async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, excludedSources) {
+async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, failoverAfterRetriesOpt, excludedSources) {
   let minBackoffMillis = minBackoffMillisOpt !== undefined ? minBackoffMillisOpt : 0;
+  let failoverAfterRetries = failoverAfterRetriesOpt !== undefined ? failoverAfterRetriesOpt : 2;
   let switchedToWorkingSource;
-  if (retry >= 2 && retry % 2 === 0) {
+  if (retry >= failoverAfterRetries && (retry - failoverAfterRetries | 0) % 2 === 0) {
     let now = Date.now();
     sourceState.lastFailedAt = now;
     let next = getNextSource(sourceManager, isRealtime, excludedSources);
@@ -497,17 +498,31 @@ async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime,
   }
 }
 
-async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger, blockNumber, method, err, excludedSources) {
-  let backoffMillis = Utils.expBackoff(100, retry, 60000);
-  let log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
-  log(logger, {
-    msg: `Block #` + blockNumber.toString() + ` is not available on the ` + sourceState.source.name + ` source yet. Instances of a load-balanced backend drift slightly around the head, so this is expected - indexing continues after an automatic retry.`,
-    method: method,
+function behindHeadBackoffMillis(retry) {
+  if (retry < 12) {
+    return Utils.expBackoff(100, retry, 1000);
+  } else {
+    return Utils.expBackoff(1000, retry - 12 | 0, 60000);
+  }
+}
+
+async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger, blockNumber, excludedSources) {
+  let backoffMillis = behindHeadBackoffMillis(retry);
+  let source = sourceState.source.name;
+  let block = blockNumber.toString();
+  let match = retry < 12 ? [
+      Logging.childTrace,
+      source + ` hasn't reached block ` + block + ` on all of its servers yet. This is normal near the latest block and resolves by itself - retrying shortly.`
+    ] : [
+      Logging.childWarn,
+      source + ` is still catching up to block ` + block + `. This is a delay on the provider's side; indexing will continue automatically, using another data source if one is configured.`
+    ];
+  match[0](logger, {
+    msg: match[1],
     retry: retry,
-    backOffMilliseconds: backoffMillis,
-    err: Utils.prettifyExn(err)
+    backOffMilliseconds: backoffMillis
   });
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, 12, excludedSources);
 }
 
 function stalledLog(retry, warnAfter, msg, stalled) {
@@ -536,7 +551,7 @@ async function retryInconsistentResponse(sourceManager, sourceState, retry, isRe
     err: Utils.prettifyExn(err)
   });
   Stdlib_Option.forEach(sourceState.source.onReorg, cb => cb());
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined, excludedSources);
 }
 
 async function retryFailedPage(sourceManager, sourceState, retry, isRealtime, logger, msg, attemptedToBlock, backoffMillis, minBackoffMillisOpt, err, excludedSources) {
@@ -549,7 +564,7 @@ async function retryFailedPage(sourceManager, sourceState, retry, isRealtime, lo
     retry: retry,
     err: Stdlib_Option.map(err, Utils.prettifyExn)
   });
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillis, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillis, undefined, excludedSources);
 }
 
 function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling) {
@@ -736,7 +751,7 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
         recordStatsInto(sourceState.requestStats, err.requestStats);
-        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$2, err.blockNumber, "getItems", err, excludedSourcesRef);
+        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$2, err.blockNumber, excludedSourcesRef);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
         await retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger$2, "getItems", err, excludedSourcesRef);
@@ -866,13 +881,10 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
       if (err.RE_EXN_ID === Source.RateLimited) {
-        let match = err._1;
-        recordStatsInto(sourceState.requestStats, match.requestStats);
-        await waitForRateLimitReset(sourceManager, match.resetMs, retry, logger$1);
+        await waitForRateLimitReset(sourceManager, err._1.resetMs, retry, logger$1);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
-        recordStatsInto(sourceState.requestStats, err.requestStats);
-        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$1, err.blockNumber, "getBlockHashes", err, undefined);
+        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$1, err.blockNumber, undefined);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
         await retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger$1, "getBlockHashes", err, undefined);
@@ -886,7 +898,7 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
           backOffMilliseconds: backoffMillis,
           err: Utils.prettifyExn(err)
         });
-        await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined);
+        await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined, undefined);
         retryRef = retryRef + 1 | 0;
       }
     }

package/src/HandlerTypeCheck.mjs

@@ -1,14 +0,0 @@
-import { Worker } from "node:worker_threads";
-
-// The compiler blocks the thread it runs on, so it gets its own and the
-// database setup carries on meanwhile.
-export const check = (cwd, files) =>
-  new Promise((resolve, reject) => {
-    const worker = new Worker(new URL("./HandlerTypeCheckWorker.mjs", import.meta.url), {
-      workerData: { cwd, files },
-    });
-    worker.once("message", resolve);
-    worker.once("error", reject);
-    // Settles nothing once the result has arrived.
-    worker.once("exit", () => reject(new Error("The handler type check exited without a result.")));
-  });

package/src/HandlerTypeCheckWorker.mjs

@@ -1,68 +0,0 @@
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { stripVTControlCharacters } from "node:util";
-import { parentPort, workerData } from "node:worker_threads";
-
-const check = ({ cwd, files }) => {
-  // The ReScript compiler checks a ReScript project's handlers, so it has no
-  // reason to set up TypeScript, and the warning would only be noise there.
-  // `rescript.json` at the root is what makes codegen treat it as ReScript.
-  const skip = (warning) => (existsSync(path.join(cwd, "rescript.json")) ? {} : { skipped: warning });
-
-  let ts;
-  try {
-    // The project's own compiler, so handlers are checked exactly as the
-    // user's editor and `tsc` check them.
-    ts = createRequire(path.join(cwd, "package.json"))("typescript");
-  } catch {
-    return skip("Skipped the handler type check: the project doesn't depend on typescript.");
-  }
-
-  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists);
-  if (configPath === undefined) {
-    return skip(
-      "Skipped the handler type check: no tsconfig.json found. Add one to type-check handlers on start, like the one envio init creates."
-    );
-  }
-
-  const host = {
-    getCanonicalFileName: (file) => file,
-    getCurrentDirectory: () => cwd,
-    getNewLine: () => "\n",
-  };
-  const format = (diagnostics) =>
-    stripVTControlCharacters(ts.formatDiagnosticsWithColorAndContext(diagnostics, host)).trimEnd();
-
-  const parsed = ts.getParsedCommandLineOfConfigFile(
-    configPath,
-    { noEmit: true },
-    {
-      ...ts.sys,
-      onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
-        throw new Error(format([diagnostic]));
-      },
-    }
-  );
-
-  // The tsconfig's files are roots, as tsc makes them, since any of them can
-  // declare globals a handler relies on. Only the handlers' errors count.
-  const handlerFiles = files.map((file) => path.resolve(cwd, file));
-  const program = ts.createProgram({
-    rootNames: [...parsed.fileNames, ...handlerFiles],
-    options: parsed.options,
-    projectReferences: parsed.projectReferences,
-  });
-
-  // Every file is a root, so each has a source file. Without one,
-  // `getSemanticDiagnostics` would check the whole program.
-  const diagnostics = handlerFiles
-    .map((file) => program.getSourceFile(file))
-    .flatMap((sourceFile) => [
-      ...program.getSyntacticDiagnostics(sourceFile),
-      ...program.getSemanticDiagnostics(sourceFile),
-    ]);
-  return diagnostics.length === 0 ? {} : { errors: format(diagnostics) };
-};
-
-parentPort.postMessage(check(workerData));

package/src/SyncWrites.res

@@ -1,86 +0,0 @@
-// The writes one round of a synchronous handler has made. A round that
-// suspends is replayed from the top, so its writes are held here rather than
-// applied: the replay has to see the store exactly as the first round did, or a
-// read-modify-write lands once per round.
-
-type table = {
-  entityConfig: Internal.entityConfig,
-  scope: Internal.chainScope,
-  changes: dict<Change.t<Internal.entity>>,
-}
-
-// A handler runs on one chain, so an entity's scope is fixed for the whole
-// round and the entity name is enough to key its table.
-type t = dict<table>
-
-let make = (): t => Dict.make()
-
-let record = (writes: t, ~entityConfig: Internal.entityConfig, ~scope, change) => {
-  let table = switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
-  | Some(table) => table
-  | None =>
-    let table = {entityConfig, scope, changes: Dict.make()}
-    writes->Dict.set(entityConfig.name, table)
-    table
-  }
-  table.changes->Dict.set(change->Change.getEntityId->EntityId.toKey, change)
-}
-
-let changesOf = (writes: t, ~entityConfig: Internal.entityConfig) =>
-  switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
-  | Some({changes}) => Some(changes)
-  | None => None
-  }
-
-// `Some(None)` is a delete this round made: the entity is known not to exist.
-let getById = (writes: t, ~entityConfig, ~entityId: string) =>
-  switch writes->changesOf(~entityConfig) {
-  | Some(changes) =>
-    changes
-    ->Utils.Dict.dangerouslyGetNonOption(entityId)
-    ->Option.map(InMemoryTable.Entity.mapChangeToEntity)
-  | None => None
-  }
-
-// What the store answered, as it reads once this round's writes land: a row
-// the round rewrote is re-tested against the filter, and one it created joins.
-let overlayFilter = (
-  writes: t,
-  entities: array<Internal.entity>,
-  ~entityConfig: Internal.entityConfig,
-  ~filter: EntityFilter.t,
-) =>
-  switch writes->changesOf(~entityConfig) {
-  | None => entities
-  | Some(changes) =>
-    let matches = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
-    let untouched =
-      entities->Array.filter(entity =>
-        !(changes->Dict.has(entity->InMemoryTable.Entity.getEntityIdUnsafe))
-      )
-    let written =
-      changes
-      ->Dict.valuesToArray
-      ->Array.filterMap(change =>
-        switch change->InMemoryTable.Entity.mapChangeToEntity {
-        | Some(entity) if matches(entity) => Some(entity)
-        | _ => None
-        }
-      )
-    untouched->Array.concat(written)
-  }
-
-// How a change lands in the in-memory store, whether written directly or
-// committed at the end of a round.
-let write = (indexerState, ~entityConfig, ~scope, change) =>
-  indexerState
-  ->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  ->InMemoryTable.Entity.set(
-    ~committedCheckpointId=indexerState->IndexerState.committedCheckpointIdFor(~scope),
-    change,
-  )
-
-let commit = (writes: t, ~indexerState) =>
-  writes->Utils.Dict.forEach(({entityConfig, scope, changes}) =>
-    changes->Utils.Dict.forEach(change => indexerState->write(~entityConfig, ~scope, change))
-  )

package/src/SyncWrites.res.mjs

@@ -1,85 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Utils from "./Utils.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
-import * as EntityFilter from "./db/EntityFilter.res.mjs";
-import * as IndexerState from "./IndexerState.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-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";
-
-function make() {
-  return {};
-}
-
-function record(writes, entityConfig, scope, change) {
-  let table = writes[entityConfig.name];
-  let table$1;
-  if (table !== undefined) {
-    table$1 = table;
-  } else {
-    let table_changes = {};
-    let table$2 = {
-      entityConfig: entityConfig,
-      scope: scope,
-      changes: table_changes
-    };
-    writes[entityConfig.name] = table$2;
-    table$1 = table$2;
-  }
-  table$1.changes[EntityId.toKey(change.entityId)] = change;
-}
-
-function changesOf(writes, entityConfig) {
-  let match = writes[entityConfig.name];
-  if (match !== undefined) {
-    return match.changes;
-  }
-}
-
-function getById(writes, entityConfig, entityId) {
-  let changes = changesOf(writes, entityConfig);
-  if (changes !== undefined) {
-    return Stdlib_Option.map(changes[entityId], InMemoryTable.Entity.mapChangeToEntity);
-  }
-}
-
-function overlayFilter(writes, entities, entityConfig, filter) {
-  let changes = changesOf(writes, entityConfig);
-  if (changes === undefined) {
-    return entities;
-  }
-  let matches = EntityFilter.makeMatcher(filter, entityConfig.table);
-  let untouched = entities.filter(entity => !(InMemoryTable.Entity.getEntityIdUnsafe(entity) in changes));
-  let written = Stdlib_Array.filterMap(Object.values(changes), change => {
-    let entity = InMemoryTable.Entity.mapChangeToEntity(change);
-    if (entity !== undefined && matches(entity)) {
-      return entity;
-    }
-  });
-  return untouched.concat(written);
-}
-
-function write(indexerState, entityConfig, scope, change) {
-  InMemoryTable.Entity.set(InMemoryStore.getInMemTable(indexerState, entityConfig, scope), IndexerState.committedCheckpointIdFor(indexerState, scope), change);
-}
-
-function commit(writes, indexerState) {
-  Utils.Dict.forEach(writes, param => {
-    let scope = param.scope;
-    let entityConfig = param.entityConfig;
-    Utils.Dict.forEach(param.changes, change => write(indexerState, entityConfig, scope, change));
-  });
-}
-
-export {
-  make,
-  record,
-  changesOf,
-  getById,
-  overlayFilter,
-  write,
-  commit,
-}
-/* Utils Not a pure module */

package/src/subgraph/abi-types.ts

@@ -1,63 +0,0 @@
-/**
- * Contract-call signatures and ABI type lists as graph codegen writes them.
- * Free of envio imports: the graph-ts shim reads them too.
- */
-
-export type ParsedSignature = {
-  name: string;
-  inputs: string;
-  outputs: string;
-};
-
-/**
- * graph codegen emits `"balanceOf(address):(uint256)"`. Types only, no names —
- * which is all `parseAbiParameters` needs.
- */
-export function parseSignature(signature: string): ParsedSignature {
-  const open = signature.indexOf("(");
-  if (open === -1) {
-    throw new Error(`Unreadable contract call signature "${signature}"`);
-  }
-  const name = signature.slice(0, open);
-
-  let depth = 0;
-  let close = -1;
-  for (let index = open; index < signature.length; index++) {
-    const char = signature[index];
-    if (char === "(") depth++;
-    if (char === ")") {
-      depth--;
-      if (depth === 0) {
-        close = index;
-        break;
-      }
-    }
-  }
-  if (close === -1) {
-    throw new Error(`Unreadable contract call signature "${signature}"`);
-  }
-
-  const inputs = signature.slice(open + 1, close);
-  const rest = signature.slice(close + 1).replace(/^:/, "");
-  const outputs = rest.startsWith("(") ? rest.slice(1, -1) : rest;
-
-  return { name, inputs, outputs };
-}
-
-/** `address,(uint256,bytes)` → `["address", "(uint256,bytes)"]`. */
-export function splitTypes(list: string): string[] {
-  const types: string[] = [];
-  let depth = 0;
-  let start = 0;
-  for (let index = 0; index < list.length; index++) {
-    const char = list[index];
-    if (char === "(") depth++;
-    else if (char === ")") depth--;
-    else if (char === "," && depth === 0) {
-      types.push(list.slice(start, index));
-      start = index + 1;
-    }
-  }
-  if (list.length > 0) types.push(list.slice(start));
-  return types;
-}