envio 3.9.0 → 3.10.0-resolvers.1

package/src/Bin.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Env from "./Env.res.mjs";
 import * as Core from "./Core.res.mjs";
 import * as Main from "./Main.res.mjs";
 import * as Utils from "./Utils.res.mjs";
@@ -11,6 +12,7 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.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";
+import * as ResolverProcess from "./resolvers/ResolverProcess.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let setEnvVar = ((k, v) => { process.env[k] = v; });
@@ -36,6 +38,11 @@ function decodeCommand(json) {
         TAG: "Migrate",
         _0: json
       };
+    case "resolvers" :
+      return {
+        TAG: "Resolvers",
+        _0: json
+      };
     case "start" :
       return {
         TAG: "Start",
@@ -65,9 +72,14 @@ async function run(args) {
     switch (match.TAG) {
       case "Start" :
         let match$1 = match._0;
+        let cwd = match$1.cwd;
         Config.prime(match$1.config);
-        process.chdir(match$1.cwd);
+        process.chdir(cwd);
         applyEnv(match$1.env);
+        let loaded = Config.load();
+        if (loaded.isDev) {
+          await ResolverProcess.startForDev(loaded, cwd);
+        }
         return await Main.start(undefined, match$1.reset, undefined, undefined, undefined);
       case "Migrate" :
         let match$2 = match._0;
@@ -76,6 +88,27 @@ async function run(args) {
       case "DropSchema" :
         Config.prime(match._0.config);
         return await Main.dropSchema();
+      case "Resolvers" :
+        let match$3 = match._0;
+        let cwd$1 = match$3.cwd;
+        Config.prime(match$3.config);
+        process.chdir(cwd$1);
+        applyEnv(match$3.env);
+        switch (match$3.mode) {
+          case "manifest" :
+            return await ResolverProcess.writeManifest(Config.load(), cwd$1);
+          case "metadata" :
+            let url = Env.Resolvers.publicUrl();
+            let handlerUrl = url !== undefined ? url : Stdlib_JsError.throwWithMessage("ENVIO_RESOLVERS_PUBLIC_URL is not set. It is the URL Hasura posts to and is baked into every action, so the metadata cannot be printed without it.");
+            let metadata = await ResolverProcess.metadataJson(Config.load(), cwd$1, handlerUrl);
+            console.log(JSON.stringify(metadata, undefined, 2));
+            return;
+          case "migrate" :
+            let match$4 = await ResolverProcess.migrate(Config.load(), cwd$1);
+            return Logging.info(match$4.applied ? `Updated Hasura to match these resolvers: ` + match$4.reasons.join("; ") : "Hasura already matches these resolvers; nothing to update");
+          default:
+            return ResolverProcess.handleSignals(await ResolverProcess.serve(Config.load(), cwd$1, undefined, undefined, undefined, undefined));
+        }
     }
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);

package/src/ChainState.res

@@ -310,7 +310,11 @@ let makeInternal = (
           chainId,
           endpointUrl: hypersyncUrl,
           apiToken,
-          onEventRegistrations,
+          onEventRegistrations: onEventRegistrations->(
+            Utils.magic: array<Internal.onEventRegistration> => array<
+              Internal.svmOnEventRegistration,
+            >
+          ),
           clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
           addressStore,
         }),
@@ -1205,21 +1209,17 @@ let markReady = (cs: t, ~readyAt) =>
     cs.timestampCaughtUpToHeadOrEndblock = Some(readyAt)
   }
 
-// Roll a chain back to a reorg target. With a progress diff, restore fetch/
-// safe-checkpoint/progress state to `newProgressBlockNumber`. A reorg chain
-// with no diff entry still rewinds fetch state + stores to the target -
-// otherwise the stale block hash stays in the store and re-triggers the same
-// reorg.
-// Returns the address registrations the storage has to delete along with it —
-// the store is what decides which ones died, so the two halves of a rollback
-// can't disagree.
-let rollback = (
-  cs: t,
-  ~newProgressBlockNumber,
-  ~eventsProcessedDiff,
-  ~rollbackTargetBlockNumber,
-  ~isReorgChain,
-): array<AddressRows.key> => {
+type progressDiff = {blockNumber: int, eventsProcessed: float}
+
+type rolledBackTo =
+  | RecomputedProgress(progressDiff)
+  | ForkBlock(int)
+  | Untouched
+
+// Returns the address registrations the storage has to delete along with the
+// chain — the store is what decides which ones died, so the two halves of a
+// rollback can't disagree.
+let rollback = (cs: t, ~rolledBackTo: rolledBackTo): array<AddressRows.key> => {
   let rollbackTo = targetBlockNumber => {
     let {fetchState, rolledBackAddresses} =
       cs.fetchState->FetchState.rollback(
@@ -1234,15 +1234,15 @@ let rollback = (
     })
   }
 
-  switch newProgressBlockNumber {
-  | Some(newProgressBlockNumber) =>
-    let newTotalEventsProcessed =
-      cs.numEventsProcessed -.
-      // Both dicts are populated together per progress-diff row, so a chain with
-      // a progress diff always has an events-processed diff too.
-      eventsProcessedDiff->Option.getOrThrow(
-        ~message="Missing events-processed diff for rolled-back chain",
-      )
+  switch rolledBackTo {
+  | RecomputedProgress({blockNumber, eventsProcessed}) =>
+    // A rollback only ever takes a chain back. The diff recomputes progress from
+    // the checkpoints still in the database, so a chain that an unwritten
+    // rollback already took below them — to a fork block only that rollback
+    // knew — would be handed their MIN back and moved forward onto blocks it
+    // never re-indexed.
+    let newProgressBlockNumber = Pervasives.min(blockNumber, cs.committedProgressBlockNumber)
+    let newTotalEventsProcessed = cs.numEventsProcessed -. eventsProcessed
 
     switch cs.safeCheckpointTracking {
     | Some(safeCheckpointTracking) =>
@@ -1260,19 +1260,15 @@ let rollback = (
     cs.processingBlockNumber = newProgressBlockNumber
     cs.numEventsProcessed = newTotalEventsProcessed
     rolledBackAddresses
-  | None =>
-    if isReorgChain {
-      let rolledBackAddresses = rollbackTo(rollbackTargetBlockNumber)
-      cs.transactionStore->TransactionStore.rollback(rollbackTargetBlockNumber)
-      cs.blockStore->BlockStore.rollback(rollbackTargetBlockNumber)
-      cs.committedProgressBlockNumber = Pervasives.min(
-        cs.committedProgressBlockNumber,
-        rollbackTargetBlockNumber,
-      )
-      cs.processingBlockNumber = Pervasives.min(cs.processingBlockNumber, rollbackTargetBlockNumber)
-      rolledBackAddresses
-    } else {
-      []
-    }
+  | ForkBlock(forkBlock) =>
+    // Rewinds the stores too, not just progress: otherwise the stale block hash
+    // survives and re-triggers the same reorg.
+    let rolledBackAddresses = rollbackTo(forkBlock)
+    cs.transactionStore->TransactionStore.rollback(forkBlock)
+    cs.blockStore->BlockStore.rollback(forkBlock)
+    cs.committedProgressBlockNumber = Pervasives.min(cs.committedProgressBlockNumber, forkBlock)
+    cs.processingBlockNumber = Pervasives.min(cs.processingBlockNumber, forkBlock)
+    rolledBackAddresses
+  | Untouched => []
   }
 }

package/src/ChainState.res.mjs

@@ -857,7 +857,7 @@ function markReady(cs, readyAt) {
   }
 }
 
-function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTargetBlockNumber, isReorgChain) {
+function rollback(cs, rolledBackTo) {
   let rollbackTo = targetBlockNumber => {
     let match = FetchState.rollback(cs.fetchState, cs.addressStore, targetBlockNumber);
     cs.fetchState = match.fetchState;
@@ -867,8 +867,13 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
       contractId: param.contractId
     }));
   };
-  if (newProgressBlockNumber !== undefined) {
-    let newTotalEventsProcessed = cs.numEventsProcessed - Stdlib_Option.getOrThrow(eventsProcessedDiff, "Missing events-processed diff for rolled-back chain");
+  if (typeof rolledBackTo !== "object") {
+    return [];
+  }
+  if (rolledBackTo.TAG === "RecomputedProgress") {
+    let match = rolledBackTo._0;
+    let newProgressBlockNumber = Primitive_int.min(match.blockNumber, cs.committedProgressBlockNumber);
+    let newTotalEventsProcessed = cs.numEventsProcessed - match.eventsProcessed;
     let safeCheckpointTracking = cs.safeCheckpointTracking;
     if (safeCheckpointTracking !== undefined) {
       cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
@@ -881,14 +886,12 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
     cs.numEventsProcessed = newTotalEventsProcessed;
     return rolledBackAddresses;
   }
-  if (!isReorgChain) {
-    return [];
-  }
-  let rolledBackAddresses$1 = rollbackTo(rollbackTargetBlockNumber);
-  cs.transactionStore.rollback(rollbackTargetBlockNumber);
-  cs.blockStore.rollback(rollbackTargetBlockNumber);
-  cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, rollbackTargetBlockNumber);
-  cs.processingBlockNumber = Primitive_int.min(cs.processingBlockNumber, rollbackTargetBlockNumber);
+  let forkBlock = rolledBackTo._0;
+  let rolledBackAddresses$1 = rollbackTo(forkBlock);
+  cs.transactionStore.rollback(forkBlock);
+  cs.blockStore.rollback(forkBlock);
+  cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, forkBlock);
+  cs.processingBlockNumber = Primitive_int.min(cs.processingBlockNumber, forkBlock);
   return rolledBackAddresses$1;
 }
 

package/src/ChainState.resi

@@ -157,10 +157,18 @@ let enterReorgThreshold: t => unit
 let advanceAfterBatch: (t, ~batch: Batch.t, ~enteringReorgThreshold: bool) => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
 let markReady: (t, ~readyAt: Date.t) => unit
-let rollback: (
-  t,
-  ~newProgressBlockNumber: option<int>,
-  ~eventsProcessedDiff: option<float>,
-  ~rollbackTargetBlockNumber: int,
-  ~isReorgChain: bool,
-) => array<AddressRows.key>
+// What a rollback's progress diff says about one chain: the block its surviving
+// checkpoints put it back to, and the events the deleted ones carried away. One
+// record because one diff row yields both — they are never known separately.
+type progressDiff = {blockNumber: int, eventsProcessed: float}
+
+// Where a rollback leaves one chain.
+type rolledBackTo =
+  | RecomputedProgress(progressDiff)
+  // The reorg chain with no checkpoint left at or below the target, so only the
+  // fork block says where it goes.
+  | ForkBlock(int)
+  // A chain this rollback doesn't reach.
+  | Untouched
+
+let rollback: (t, ~rolledBackTo: rolledBackTo) => array<AddressRows.key>

package/src/Config.res

@@ -94,6 +94,9 @@ type t = {
   name: string,
   description: option<string>,
   handlers: string,
+  // Relative path to the module declaring custom GraphQL resolvers, when the
+  // project ships them. None means entity fields only.
+  resolvers: option<string>,
   contractHandlers: array<contractHandler>,
   shouldRollbackOnReorg: bool,
   shouldSaveFullHistory: bool,
@@ -174,28 +177,26 @@ let publicConfigChainSchema = S.schema(s =>
   }
 )
 
+type svmAccountSlotItem = {"name": option<string>, "optional": option<bool>}
+
+let svmAccountSlotSchema: S.t<svmAccountSlotItem> = S.schema(s =>
+  {
+    "name": s.matches(S.option(S.string)),
+    "optional": s.matches(S.option(S.bool)),
+  }
+)
+
+let svmAccountSlotFromItem = (slot: svmAccountSlotItem): Internal.svmAccountSlot =>
+  switch (slot["name"], slot["optional"]) {
+  | (None, _) => Unnamed
+  | (Some(name), Some(true)) => Optional(name)
+  | (Some(name), _) => Required(name)
+  }
+
 let svmEventDescriptorSchema = S.schema(s =>
   {
     "discriminator": s.matches(S.option(S.string)),
-    "discriminatorByteLen": s.matches(S.int),
-    // An array of AND-groups OR-ed together: the CLI normalizes both the flat
-    // and `any_of` YAML shapes to `Vec<Vec<SvmAccountFilterJson>>`.
-    "accountFilters": s.matches(
-      S.option(
-        S.array(
-          S.array(
-            S.schema(s =>
-              {
-                "position": s.matches(S.int),
-                "values": s.matches(S.array(S.string)),
-              }
-            ),
-          ),
-        ),
-      ),
-    ),
-    "isInner": s.matches(S.option(S.bool)),
-    "accounts": s.matches(S.option(S.array(S.string))),
+    "accounts": s.matches(S.option(S.array(svmAccountSlotSchema))),
     "args": s.matches(S.option(S.json(~validate=false))),
   }
 )
@@ -341,6 +342,7 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Tab
 
   let (fieldType, baseSchema) = switch typ {
   | "string" => (Table.String, S.string->S.toUnknown)
+  | "bytes" => (Table.Bytea, Utils.Schema.bytes->S.toUnknown)
   | "boolean" => (Table.Boolean, S.bool->S.toUnknown)
   | "int" => (Table.Int32, S.int->S.toUnknown)
   | "bigint" => (Table.BigInt({precision: ?prop["precision"]}), Utils.BigInt.schema->S.toUnknown)
@@ -374,13 +376,13 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Tab
   | other => JsError.throwWithMessage("Unknown field type in entity config: " ++ other)
   }
 
-  let fieldSchema = if isArray {
-    S.array(baseSchema)->S.toUnknown
-  } else {
-    baseSchema
+  let fieldSchema = switch (fieldType, isArray) {
+  | (Table.Bytea, true) => Utils.Schema.bytesArray->S.toUnknown
+  | (_, true) => S.array(baseSchema)->S.toUnknown
+  | (_, false) => baseSchema
   }
   let fieldSchema = if isNullable {
-    S.null(fieldSchema)->S.toUnknown
+    Utils.Schema.nullTolerant(fieldSchema)->S.toUnknown
   } else {
     fieldSchema
   }
@@ -550,6 +552,7 @@ let publicConfigSchema = S.schema(s =>
     "name": s.matches(S.string),
     "description": s.matches(S.option(S.string)),
     "handlers": s.matches(S.option(S.string)),
+    "resolvers": s.matches(S.option(S.string)),
     "isDev": s.matches(S.option(S.bool)),
     "fullBatchSize": s.matches(S.option(S.int)),
     "rollbackOnReorg": s.matches(S.option(S.bool)),
@@ -753,12 +756,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               Utils.magic: _ => {
                 "svm": option<{
                   "discriminator": option<string>,
-                  "discriminatorByteLen": int,
-                  "accountFilters": option<
-                    array<array<{"position": int, "values": array<string>}>>,
-                  >,
-                  "isInner": option<bool>,
-                  "accounts": option<array<string>>,
+                  "accounts": option<array<svmAccountSlotItem>>,
                   "args": option<JSON.t>,
                 }>,
               }
@@ -770,26 +768,12 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               `SVM instruction ${contractName}.${eventName} is missing the "svm" descriptor in internal config`,
             )
           }
-          let accountFilters =
-            svm["accountFilters"]
-            ->Option.getOr([])
-            ->Array.map(group =>
-              group->Array.map(
-                af => {
-                  Internal.position: af["position"],
-                  values: af["values"]->SvmTypes.Pubkey.fromStringsUnsafe,
-                },
-              )
-            )
           (EventConfigBuilder.buildSvmInstructionEventConfig(
             ~contractName,
             ~instructionName=eventName,
             ~programId,
             ~discriminator=svm["discriminator"],
-            ~discriminatorByteLen=svm["discriminatorByteLen"],
-            ~accountFilters,
-            ~isInner=svm["isInner"],
-            ~accounts=svm["accounts"]->Option.getOr([]),
+            ~accounts=svm["accounts"]->Option.getOr([])->Array.map(svmAccountSlotFromItem),
             ~args=svm["args"]->Option.getOr(JSON.Null),
             ~definedTypes=svmDefinedTypes,
           ) :> Internal.eventConfig)
@@ -1047,6 +1031,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     name: publicConfig["name"],
     description: publicConfig["description"],
     handlers: publicConfig["handlers"]->Option.getOr("src/handlers"),
+    resolvers: publicConfig["resolvers"],
     contractHandlers,
     shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getOr(true),
     shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getOr(false),
@@ -1070,6 +1055,14 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   }
 }
 
+// With no cross-chain entity, a reorg on one chain can never have changed a row
+// another chain owns, so its rollback stays isolated to that chain instead of
+// dragging every sibling back with it. A single chain has no sibling to spare,
+// and narrowing its rollback would only buy it a predicate that always holds.
+let isIsolatedMultichain = (config: t) =>
+  config.chainMap->ChainMap.keys->Array.length > 1 &&
+    config.userEntities->Array.every(entityConfig => !entityConfig.crossChain)
+
 // Canonicalize a user-provided address to the configured casing so it matches
 // addresses parsed from config.yaml during routing. HyperSync/RPC data arrives
 // already canonical; only user-land input (simulate srcAddress, contractRegister
@@ -1141,8 +1134,17 @@ let getEventConfig = (config: t, ~contractName, ~eventName, ~chainId: option<Cha
   })
 }
 
-let shouldSaveHistory = (config, ~isInReorgThreshold) =>
-  config.shouldSaveFullHistory || (config.shouldRollbackOnReorg && isInReorgThreshold)
+// A chain that can't be rolled back (maxReorgDepth = 0) has no history to keep,
+// unless a cross-chain entity lets another chain's rollback reach its rows.
+let shouldSaveHistory = (config, ~isInReorgThreshold, ~chainId: option<ChainId.t>=?) =>
+  config.shouldSaveFullHistory ||
+  (config.shouldRollbackOnReorg &&
+  isInReorgThreshold &&
+  switch chainId {
+  | Some(chainId) if config->isIsolatedMultichain =>
+    (config.chainMap->ChainMap.get(chainId)).maxReorgDepth > 0
+  | _ => true
+  })
 
 let shouldPruneHistory = (config, ~isInReorgThreshold) =>
   !config.shouldSaveFullHistory && (config.shouldRollbackOnReorg && isInReorgThreshold)
@@ -1172,8 +1174,11 @@ let getPublicConfigJson = () =>
 
 // Drops source URLs from each chain so RPC/hypersync edits don't trigger
 // the resume-time compat check (and don't end up in `envio_info`). Also
-// drops `isDev`, which toggles between `envio dev` and `envio start` and
-// has no bearing on schema/indexing compatibility.
+// drops two fields that have no bearing on schema/indexing compatibility:
+// `isDev`, which toggles between `envio dev` and `envio start`, and
+// `resolvers`, which names where the custom GraphQL resolvers live. Without
+// the latter, adding `resolvers:` to a running indexer reads as an
+// incompatible config change and it refuses to resume.
 let stripSensitiveData = (json: JSON.t): JSON.t => {
   let cloned = json->JSON.stringify->JSON.parseOrThrow
   let stripChains = (ecosystem: option<JSON.t>) =>
@@ -1200,6 +1205,7 @@ let stripSensitiveData = (json: JSON.t): JSON.t => {
   switch cloned {
   | Object(obj) => {
       obj->Utils.Dict.deleteInPlace("isDev")
+      obj->Utils.Dict.deleteInPlace("resolvers")
       stripChains(obj->Dict.get("evm"))
       stripChains(obj->Dict.get("fuel"))
       stripChains(obj->Dict.get("svm"))
@@ -1362,6 +1368,33 @@ let throwIfIncompatible = (
   }
 }
 
+let throwIfResumeIncompatible = (
+  ~storedEnvioInfo: option<JSON.t>,
+  ~storedContractMapping: ContractMapping.t,
+  ~envioInfo: JSON.t,
+  ~contractMapping: ContractMapping.t,
+  ~resetCommand: string,
+  ~runCommand: option<string>,
+) => {
+  let changedPaths = switch storedEnvioInfo {
+  | None => ["storage was initialized by an older envio version"]
+  | Some(stored) => diffPaths(~stored, ~current=envioInfo)
+  }
+  let changedPaths =
+    storedContractMapping->ContractMapping.isEqual(contractMapping)
+      ? changedPaths
+      : changedPaths->Array.concat(["contracts"])
+  let hasClickhouse = switch envioInfo {
+  | Object(d) =>
+    switch d->Dict.get("storage") {
+    | Some(Object(s)) => s->Dict.get("clickhouse") == Some(Boolean(true))
+    | _ => false
+    }
+  | _ => false
+  }
+  throwIfIncompatible(changedPaths, ~resetCommand, ~runCommand, ~hasClickhouse)
+}
+
 // The returned value is a pure function of the JSON: it holds only event
 // definitions, never handler/contractRegister/where state (that's layered on
 // separately as `HandlerRegister.registrationsByChainId`). That purity is

package/src/Config.res.mjs

@@ -17,6 +17,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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";
 import * as ContractMapping from "./ContractMapping.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -71,15 +72,34 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
   contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(chainContractSchema)))
 }));
 
+let svmAccountSlotSchema = S$RescriptSchema.schema(s => ({
+  name: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+  optional: s.m(S$RescriptSchema.option(S$RescriptSchema.bool))
+}));
+
+function svmAccountSlotFromItem(slot) {
+  let match = slot.name;
+  let match$1 = slot.optional;
+  if (match !== undefined) {
+    if (match$1 !== undefined && match$1) {
+      return {
+        TAG: "Optional",
+        _0: match
+      };
+    } else {
+      return {
+        TAG: "Required",
+        _0: match
+      };
+    }
+  } else {
+    return "Unnamed";
+  }
+}
+
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
-  discriminatorByteLen: s.m(S$RescriptSchema.int),
-  accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
-    position: s.m(S$RescriptSchema.int),
-    values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
-  })))))),
-  isInner: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
-  accounts: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
+  accounts: s.m(S$RescriptSchema.option(S$RescriptSchema.array(svmAccountSlotSchema))),
   args: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
 }));
 
@@ -226,6 +246,12 @@ function getFieldTypeAndSchema(prop, enumConfigsByName) {
         S$RescriptSchema.bool
       ];
       break;
+    case "bytes" :
+      match = [
+        "Bytea",
+        Utils.Schema.bytes
+      ];
+      break;
     case "date" :
       match = [
         "Date",
@@ -277,10 +303,20 @@ function getFieldTypeAndSchema(prop, enumConfigsByName) {
       match = Stdlib_JsError.throwWithMessage("Unknown field type in entity config: " + typ);
   }
   let baseSchema = match[1];
-  let fieldSchema = isArray ? S$RescriptSchema.array(baseSchema) : baseSchema;
-  let fieldSchema$1 = isNullable ? S$RescriptSchema.$$null(fieldSchema) : fieldSchema;
+  let fieldType = match[0];
+  let fieldSchema;
+  let exit = 0;
+  if (typeof fieldType !== "object" && fieldType === "Bytea" && isArray) {
+    fieldSchema = Utils.Schema.bytesArray;
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    fieldSchema = isArray ? S$RescriptSchema.array(baseSchema) : baseSchema;
+  }
+  let fieldSchema$1 = isNullable ? Utils.Schema.nullTolerant(fieldSchema) : fieldSchema;
   return [
-    match[0],
+    fieldType,
     fieldSchema$1,
     isNullable,
     isArray,
@@ -378,6 +414,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   handlers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+  resolvers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   isDev: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   fullBatchSize: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
@@ -527,11 +564,7 @@ function fromPublic(publicConfigJson) {
               ) : addresses[0];
             let s = eventItem.svm;
             let svm = s !== undefined ? Primitive_option.valFromOption(s) : Stdlib_JsError.throwWithMessage(`SVM instruction ` + contractName + `.` + eventName + ` is missing the "svm" descriptor in internal config`);
-            let accountFilters = Stdlib_Option.getOr(svm.accountFilters, []).map(group => group.map(af => ({
-              position: af.position,
-              values: af.values
-            })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, Stdlib_Option.getOr(svm.accounts, []).map(svmAccountSlotFromItem), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
         }
       });
     } else {
@@ -703,6 +736,7 @@ function fromPublic(publicConfigJson) {
     name: publicConfig.name,
     description: publicConfig.description,
     handlers: Stdlib_Option.getOr(publicConfig.handlers, "src/handlers"),
+    resolvers: publicConfig.resolvers,
     contractHandlers: contractHandlers,
     shouldRollbackOnReorg: Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true),
     shouldSaveFullHistory: Stdlib_Option.getOr(publicConfig.saveFullHistory, false),
@@ -726,6 +760,14 @@ function fromPublic(publicConfigJson) {
   };
 }
 
+function isIsolatedMultichain(config) {
+  if (ChainMap.keys(config.chainMap).length > 1) {
+    return config.userEntities.every(entityConfig => !entityConfig.crossChain);
+  } else {
+    return false;
+  }
+}
+
 function normalizeUserAddress(config, address) {
   let match = config.ecosystem.name;
   switch (match) {
@@ -789,11 +831,15 @@ function getEventConfig(config, contractName, eventName, chainId) {
   });
 }
 
-function shouldSaveHistory(config, isInReorgThreshold) {
+function shouldSaveHistory(config, isInReorgThreshold, chainId) {
   if (config.shouldSaveFullHistory) {
     return true;
-  } else if (config.shouldRollbackOnReorg) {
-    return isInReorgThreshold;
+  } else if (config.shouldRollbackOnReorg && isInReorgThreshold) {
+    if (chainId !== undefined && isIsolatedMultichain(config)) {
+      return ChainMap.get(config.chainMap, Primitive_option.valFromOption(chainId)).maxReorgDepth > 0;
+    } else {
+      return true;
+    }
   } else {
     return false;
   }
@@ -864,6 +910,7 @@ function stripSensitiveData(json) {
   };
   if (typeof cloned === "object" && cloned !== null && !Array.isArray(cloned)) {
     Utils.Dict.deleteInPlace(cloned, "isDev");
+    Utils.Dict.deleteInPlace(cloned, "resolvers");
     stripChains(cloned["evm"]);
     stripChains(cloned["fuel"]);
     stripChains(cloned["svm"]);
@@ -1031,6 +1078,19 @@ function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhou
   Stdlib_JsError.throwWithMessage(`The following config changes are incompatible with the existing indexer data:\n\n` + bullets + `\n\nPick one:\n  1. ` + padTo(option1, col) + `# resume indexing where it left off\n  2. ` + padTo(resetCommand, col) + `# delete all indexed data and start over` + option3);
 }
 
+function throwIfResumeIncompatible(storedEnvioInfo, storedContractMapping, envioInfo, contractMapping, resetCommand, runCommand) {
+  let changedPaths = storedEnvioInfo !== undefined ? diffPaths(storedEnvioInfo, envioInfo) : ["storage was initialized by an older envio version"];
+  let changedPaths$1 = ContractMapping.isEqual(storedContractMapping, contractMapping) ? changedPaths : changedPaths.concat(["contracts"]);
+  let hasClickhouse;
+  if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
+    let match = envioInfo["storage"];
+    hasClickhouse = typeof match === "object" && match !== null && !Array.isArray(match) ? Primitive_object.equal(match["clickhouse"], true) : false;
+  } else {
+    hasClickhouse = false;
+  }
+  throwIfIncompatible(changedPaths$1, resetCommand, runCommand, hasClickhouse);
+}
+
 function load() {
   let c = cached.contents;
   if (c !== undefined) {
@@ -1052,6 +1112,8 @@ export {
   rpcConfigSchema,
   chainContractSchema,
   publicConfigChainSchema,
+  svmAccountSlotSchema,
+  svmAccountSlotFromItem,
   svmEventDescriptorSchema,
   svmAbiSchema,
   contractEventItemSchema,
@@ -1075,6 +1137,7 @@ export {
   publicConfigSchema,
   contractMappingOf,
   fromPublic,
+  isIsolatedMultichain,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
@@ -1087,6 +1150,7 @@ export {
   canonicalJson,
   diffPaths,
   throwIfIncompatible,
+  throwIfResumeIncompatible,
   load,
   getPgUserEntities,
 }