envio 3.0.2-svm-alpha.0 → 3.0.2

package/src/Config.res

@@ -30,7 +30,7 @@ type evmRpcConfig = {
 type sourceConfig =
   | EvmSourceConfig({hypersync: option<string>, rpcs: array<evmRpcConfig>})
   | FuelSourceConfig({hypersync: string})
-  | SvmSourceConfig({hypersync: option<string>, rpc: string})
+  | SvmSourceConfig({rpc: string})
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
@@ -201,38 +201,6 @@ let publicConfigChainSchema = S.schema(s =>
   }
 )
 
-let svmEventDescriptorSchema = S.schema(s =>
-  {
-    "discriminator": s.matches(S.option(S.string)),
-    "discriminatorByteLen": s.matches(S.int),
-    "includeTransaction": s.matches(S.bool),
-    "includeLogs": s.matches(S.bool),
-    "accountFilters": s.matches(
-      S.option(
-        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))),
-    "args": s.matches(S.option(S.json(~validate=false))),
-  }
-)
-
-let svmAbiSchema = S.schema(s =>
-  {
-    "programId": s.matches(S.string),
-    "definedTypes": s.matches(S.json(~validate=false)),
-    "source": s.matches(S.string),
-  }
-)
-
 let contractEventItemSchema = S.schema(s =>
   {
     "event": s.matches(S.string),
@@ -242,7 +210,6 @@ let contractEventItemSchema = S.schema(s =>
     "kind": s.matches(S.option(S.string)),
     "blockFields": s.matches(S.option(S.array(Internal.evmBlockFieldSchema))),
     "transactionFields": s.matches(S.option(S.array(Internal.evmTransactionFieldSchema))),
-    "svm": s.matches(S.option(svmEventDescriptorSchema)),
   }
 )
 
@@ -252,8 +219,6 @@ let contractConfigSchema = S.schema(s =>
     "handler": s.matches(S.option(S.string)),
     // EVM-specific: event signatures for HyperSync queries
     "events": s.matches(S.option(S.array(contractEventItemSchema))),
-    // SVM-only: program-level Borsh schema (defined-types registry, source).
-    "svmAbi": s.matches(S.option(svmAbiSchema)),
   }
 )
 
@@ -261,10 +226,6 @@ let publicConfigEcosystemSchema = S.schema(s =>
   {
     "chains": s.matches(S.dict(publicConfigChainSchema)),
     "contracts": s.matches(S.option(S.dict(contractConfigSchema))),
-    // SVM-only alias: programs are the SVM analog of EVM/Fuel contracts.
-    // Parsed via the same `contractConfigSchema` and read in `fromPublic`'s
-    // `publicContractsConfig` switch.
-    "programs": s.matches(S.option(S.dict(contractConfigSchema))),
   }
 )
 
@@ -562,19 +523,10 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => false
   }
 
-  // Parse contract configs (ABIs, events, handlers).
-  // SVM stores them under `svm.programs` in the public JSON — the per-program
-  // events drive `indexer.onInstruction` registration the same way EVM/Fuel
-  // contracts drive `onEvent`.
-  let publicContractsConfig = switch (
-    ecosystemName,
-    publicConfig["evm"],
-    publicConfig["fuel"],
-    publicConfig["svm"],
-  ) {
-  | (Ecosystem.Evm, Some(evm), _, _) => evm["contracts"]
-  | (Ecosystem.Fuel, _, Some(fuel), _) => fuel["contracts"]
-  | (Ecosystem.Svm, _, _, Some(svm)) => svm["programs"]
+  // Parse contract configs (ABIs, events, handlers)
+  let publicContractsConfig = switch (ecosystemName, publicConfig["evm"], publicConfig["fuel"]) {
+  | (Ecosystem.Evm, Some(evm), _) => evm["contracts"]
+  | (Ecosystem.Fuel, _, Some(fuel)) => fuel["contracts"]
   | _ => None
   }
 
@@ -597,7 +549,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     "abi": EvmTypes.Abi.t,
     "eventSignatures": array<string>,
     "events": option<array<_>>,
-    "svmAbi": option<{"programId": string, "definedTypes": JSON.t, "source": string}>,
   }> = Dict.make()
   switch publicContractsConfig {
   | Some(contractsDict) =>
@@ -610,40 +561,21 @@ let fromPublic = (publicConfigJson: JSON.t) => {
       | Some(events) => events->Array.map(eventItem => eventItem["event"])
       | None => []
       }
-      let widened =
-        contractConfig->(
-          Utils.magic: _ => {
-            "svmAbi": option<{"programId": string, "definedTypes": JSON.t, "source": string}>,
-          }
-        )
       contractDataByName->Dict.set(
         capitalizedName,
-        {
-          "abi": abi,
-          "eventSignatures": eventSignatures,
-          "events": contractConfig["events"],
-          "svmAbi": widened["svmAbi"],
-        },
+        {"abi": abi, "eventSignatures": eventSignatures, "events": contractConfig["events"]},
       )
     })
   | None => ()
   }
 
-  // Build event configs for a contract from JSON event items.
-  //
-  // `~addresses` is the chain-side address list. For SVM programs it's the
-  // single base58 program_id — wired onto each instruction's event config so
-  // the source can build `(programId, discriminator)`-keyed InstructionSelections.
-  // EVM and Fuel ignore it (the address lives in `ChainContract.addresses` and
-  // is looked up at dispatch time, not stamped on the event).
+  // Build event configs for a contract from JSON event items
   let buildContractEvents = (
     ~contractName,
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
     ~startBlock: option<int>,
-    ~addresses: array<string>,
-    ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
     switch events {
     | None => []
@@ -674,65 +606,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               `Fuel event ${contractName}.${eventName} is missing "kind" in internal config`,
             )
           }
-        | Ecosystem.Svm =>
-          let programId = switch addresses {
-          | [pid] => pid->SvmTypes.Pubkey.fromStringUnsafe
-          | [] =>
-            JsError.throwWithMessage(
-              `SVM program ${contractName} on chain ${chainId->Int.toString} is missing a program_id`,
-            )
-          | _ =>
-            JsError.throwWithMessage(
-              `SVM program ${contractName} on chain ${chainId->Int.toString} has multiple addresses; a program is uniquely identified by a single program_id`,
-            )
-          }
-          let widenedEventItem =
-            eventItem->(
-              Utils.magic: _ => {
-                "svm": option<{
-                  "discriminator": option<string>,
-                  "discriminatorByteLen": int,
-                  "includeTransaction": bool,
-                  "includeLogs": bool,
-                  "accountFilters": option<
-                    array<{"position": int, "values": array<string>}>,
-                  >,
-                  "isInner": option<bool>,
-                  "accounts": option<array<string>>,
-                  "args": option<JSON.t>,
-                }>,
-              }
-            )
-          let svm = switch widenedEventItem["svm"] {
-          | Some(s) => s
-          | None =>
-            JsError.throwWithMessage(
-              `SVM instruction ${contractName}.${eventName} is missing the "svm" descriptor in internal config`,
-            )
-          }
-          let accountFilters =
-            (svm["accountFilters"]->Option.getOr([]))->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"],
-            ~includeTransaction=svm["includeTransaction"],
-            ~includeLogs=svm["includeLogs"],
-            ~accountFilters,
-            ~isInner=svm["isInner"],
-            ~isWildcard=false,
-            ~handler=None,
-            ~contractRegister=None,
-            ~accounts=svm["accounts"]->Option.getOr([]),
-            ~args=svm["args"]->Option.getOr(JSON.Null),
-            ~definedTypes=svmDefinedTypes,
-            ~startBlock?,
-          ) :> Internal.eventConfig)
         | _ =>
           (EventConfigBuilder.buildEvmEventConfig(
             ~contractName,
@@ -792,11 +665,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         ->Dict.toArray
         ->Array.map(((capitalizedName, contractData)) => {
           let chainContract = chainContracts->Dict.get(capitalizedName)
-          let rawAddresses =
+          let addresses =
             chainContract
             ->Option.flatMap(cc => cc["addresses"])
             ->Option.getOr([])
-          let addresses = rawAddresses->Array.map(parseAddress)
+            ->Array.map(parseAddress)
           let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
 
           // Build event configs from JSON (field selections resolved inline)
@@ -810,10 +683,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~abi=contractData["abi"],
             ~chainId,
             ~startBlock,
-            ~addresses=rawAddresses,
-            ~svmDefinedTypes=contractData["svmAbi"]
-            ->Option.map(a => a["definedTypes"])
-            ->Option.getOr(JSON.Null),
           )
 
           {
@@ -879,11 +748,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
-        | Some(rpc) =>
-          SvmSourceConfig({
-            hypersync: publicChainConfig["hypersync"],
-            rpc,
-          })
+        | Some(rpc) => SvmSourceConfig({rpc: rpc})
         | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }
@@ -1092,11 +957,18 @@ let rec canonicalJson = (json: JSON.t): JSON.t =>
   }
 
 // Returns dotted leaf paths (`a.b[i].c`) where `stored` differs from
-// `current`. Skips subtrees whose canonical JSON matches.
+// `current`, restricted to the highest-priority top-level tier with any
+// diff. Tiers in order: version → name → storage → ecosystem
+// (evm/fuel/svm) → entities → other top-level keys. The first tier
+// containing a diff is the only one rendered; lower tiers are silenced
+// so a single noisy section doesn't bury the actionable change.
 let diffPaths = (~stored: JSON.t, ~current: JSON.t): array<string> => {
+  let canonEq = (a: JSON.t, b: JSON.t) =>
+    JSON.stringify(canonicalJson(a)) === JSON.stringify(canonicalJson(b))
+
   let acc = []
   let rec go = (s: JSON.t, c: JSON.t, prefix: string) => {
-    if JSON.stringify(canonicalJson(s)) === JSON.stringify(canonicalJson(c)) {
+    if canonEq(s, c) {
       ()
     } else {
       switch (s, c) {
@@ -1122,25 +994,91 @@ let diffPaths = (~stored: JSON.t, ~current: JSON.t): array<string> => {
           | (Some(sv), Some(cv)) => go(sv, cv, p)
           }
         }
-      | _ =>
-        // Type mismatch or scalar diff
-        acc->Array.push(prefix === "" ? "<root>" : prefix)->ignore
+      | _ => acc->Array.push(prefix === "" ? "<root>" : prefix)->ignore
       }
     }
   }
-  go(stored, current, "")
+
+  let getTopKey = (j: JSON.t, k: string) =>
+    switch j {
+    | Object(d) => d->Dict.get(k)
+    | _ => None
+    }
+  let topKeyDiffers = (k: string) =>
+    switch (getTopKey(stored, k), getTopKey(current, k)) {
+    | (None, None) => false
+    | (None, _) | (_, None) => true
+    | (Some(s), Some(c)) => !canonEq(s, c)
+    }
+  let runTier = (keys: array<string>) =>
+    keys->Array.forEach(k =>
+      switch (getTopKey(stored, k), getTopKey(current, k)) {
+      | (None, None) => ()
+      | (None, _) | (_, None) => acc->Array.push(k)->ignore
+      | (Some(s), Some(c)) => go(s, c, k)
+      }
+    )
+
+  switch (stored, current) {
+  | (Object(sObj), Object(cObj)) =>
+    let tiers = [["version"], ["name"], ["storage"], ["evm", "fuel", "svm"], ["entities"]]
+    let firstHit = tiers->Array.reduce(None, (acc, tier) =>
+      switch acc {
+      | Some(_) => acc
+      | None =>
+        switch tier->Array.filter(topKeyDiffers) {
+        | [] => None
+        | hits => Some(hits)
+        }
+      }
+    )
+    switch firstHit {
+    | Some(hits) => runTier(hits)
+    | None =>
+      let knownSet = Utils.Set.fromArray(tiers->Belt.Array.concatMany)
+      let extras =
+        Utils.Set.fromArray(Array.concat(sObj->Dict.keysToArray, cObj->Dict.keysToArray))
+        ->Utils.Set.toArray
+        ->Array.filter(k => !(knownSet->Utils.Set.has(k)))
+        ->Array.toSorted(String.compare)
+        ->Array.filter(topKeyDiffers)
+      runTier(extras)
+    }
+  | _ => go(stored, current, "")
+  }
   acc
 }
 
 // Throws an `incompatible config` error listing each path in `changedPaths`,
-// plus the revert/reset remediation. `~resetCommand` lets each call site
-// (`envio dev -r` / `envio start -r` / `envio local db-migrate setup`)
-// surface the right wipe-and-restart command.
-let throwIfIncompatible = (changedPaths: array<string>, ~resetCommand: string) => {
+// plus the remediation options. `~resetCommand` is rendered as-is for
+// option 2 (the wipe-and-redo). `~runCommand` controls option 3 (parallel
+// indexer recipe): when `None`, option 3 is omitted — the migrate flow
+// uses this because running a second indexer doesn't apply.
+// `~hasClickhouse` adds the extra env line so users running both
+// Postgres and Clickhouse get a complete override.
+let throwIfIncompatible = (
+  changedPaths: array<string>,
+  ~resetCommand: string,
+  ~runCommand: option<string>,
+  ~hasClickhouse: bool,
+) => {
   if changedPaths->Array.length > 0 {
     let bullets = changedPaths->Array.map(p => `    - ${p}`)->Array.joinUnsafe("\n")
+    let option1 = "Revert the changes above"
+    let padTo = (s, col) => s ++ " "->String.repeat(Math.Int.max(col - String.length(s), 1))
+    let col = Math.Int.max(String.length(option1), String.length(resetCommand)) + 2
+    let option3 = switch runCommand {
+    | None => ""
+    | Some(cmd) =>
+      let clickhouseLine = hasClickhouse ? "       ENVIO_CLICKHOUSE_DATABASE=<new_db> \\\n" : ""
+      `\n  3. Run a second indexer alongside this one — keep both datasets:\n       ENVIO_PG_SCHEMA=<new_schema> \\\n${clickhouseLine}       ENVIO_INDEXER_PORT=<new_port> \\\n       ${cmd}`
+    }
     JsError.throwWithMessage(
-      `The following config changes are incompatible with the existing indexer data:\n\n${bullets}\n\nPick one:\n\n  1. Revert the changes above    # resume indexing where it left off\n  2. ${resetCommand}                # wipe the database and re-index from scratch`,
+      `The following config changes are incompatible with the existing indexer data:\n\n${bullets}\n\nPick one:\n  1. ${option1->padTo(
+          col,
+        )}# resume indexing where it left off\n  2. ${resetCommand->padTo(
+          col,
+        )}# delete all indexed data and start over${option3}`,
     )
   }
 }

package/src/Config.res.mjs

@@ -113,26 +113,6 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
   contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(chainContractSchema)))
 }));
 
-let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
-  discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
-  discriminatorByteLen: s.m(S$RescriptSchema.int),
-  includeTransaction: s.m(S$RescriptSchema.bool),
-  includeLogs: s.m(S$RescriptSchema.bool),
-  accountFilters: s.m(S$RescriptSchema.option(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))),
-  args: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
-}));
-
-let svmAbiSchema = S$RescriptSchema.schema(s => ({
-  programId: s.m(S$RescriptSchema.string),
-  definedTypes: s.m(S$RescriptSchema.json(false)),
-  source: s.m(S$RescriptSchema.string)
-}));
-
 let contractEventItemSchema = S$RescriptSchema.schema(s => ({
   event: s.m(S$RescriptSchema.string),
   name: s.m(S$RescriptSchema.string),
@@ -140,21 +120,18 @@ let contractEventItemSchema = S$RescriptSchema.schema(s => ({
   params: s.m(S$RescriptSchema.option(S$RescriptSchema.array(EventConfigBuilder.eventParamSchema))),
   kind: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmBlockFieldSchema))),
-  transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema))),
-  svm: s.m(S$RescriptSchema.option(svmEventDescriptorSchema))
+  transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema)))
 }));
 
 let contractConfigSchema = S$RescriptSchema.schema(s => ({
   abi: s.m(S$RescriptSchema.json(false)),
   handler: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
-  events: s.m(S$RescriptSchema.option(S$RescriptSchema.array(contractEventItemSchema))),
-  svmAbi: s.m(S$RescriptSchema.option(svmAbiSchema))
+  events: s.m(S$RescriptSchema.option(S$RescriptSchema.array(contractEventItemSchema)))
 }));
 
 let publicConfigEcosystemSchema = S$RescriptSchema.schema(s => ({
   chains: s.m(S$RescriptSchema.dict(publicConfigChainSchema)),
-  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema))),
-  programs: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
+  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
 }));
 
 let publicConfigEvmSchema = S$RescriptSchema.schema(s => ({
@@ -442,7 +419,6 @@ function fromPublic(publicConfigJson) {
   let lowercaseAddresses = evm !== undefined ? Stdlib_Option.getOr(Primitive_option.valFromOption(evm).addressFormat, "checksum") === "lowercase" : false;
   let match$4 = publicConfig.evm;
   let match$5 = publicConfig.fuel;
-  let match$6 = publicConfig.svm;
   let publicContractsConfig;
   switch (ecosystemName) {
     case "evm" :
@@ -452,25 +428,25 @@ function fromPublic(publicConfigJson) {
       publicContractsConfig = match$5 !== undefined ? Primitive_option.valFromOption(match$5).contracts : undefined;
       break;
     case "svm" :
-      publicContractsConfig = match$6 !== undefined ? Primitive_option.valFromOption(match$6).programs : undefined;
+      publicContractsConfig = undefined;
       break;
   }
   let evm$1 = publicConfig.evm;
-  let match$7;
+  let match$6;
   if (evm$1 !== undefined) {
     let evm$2 = Primitive_option.valFromOption(evm$1);
-    match$7 = [
+    match$6 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields.concat(Stdlib_Option.getOr(evm$2.globalBlockFields, []))),
       new Set(Stdlib_Option.getOr(evm$2.globalTransactionFields, []))
     ];
   } else {
-    match$7 = [
+    match$6 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields),
       new Set()
     ];
   }
-  let globalTransactionFieldsSet = match$7[1];
-  let globalBlockFieldsSet = match$7[0];
+  let globalTransactionFieldsSet = match$6[1];
+  let globalBlockFieldsSet = match$6[0];
   let contractDataByName = {};
   if (publicContractsConfig !== undefined) {
     Object.entries(publicContractsConfig).forEach(param => {
@@ -482,13 +458,11 @@ function fromPublic(publicConfigJson) {
       contractDataByName[capitalizedName] = {
         abi: abi,
         eventSignatures: eventSignatures,
-        events: contractConfig.events,
-        svmAbi: contractConfig.svmAbi
+        events: contractConfig.events
       };
     });
   }
-  let buildContractEvents = (contractName, events, abi, chainId, startBlock, addresses, svmDefinedTypesOpt) => {
-    let svmDefinedTypes = svmDefinedTypesOpt !== undefined ? svmDefinedTypesOpt : null;
+  let buildContractEvents = (contractName, events, abi, chainId, startBlock) => {
     if (events !== undefined) {
       return events.map(eventItem => {
         let eventName = eventItem.name;
@@ -496,27 +470,17 @@ function fromPublic(publicConfigJson) {
         let params = Stdlib_Option.getOr(eventItem.params, []);
         let kind = eventItem.kind;
         switch (ecosystemName) {
-          case "evm" :
-            return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, false, undefined, undefined, undefined, chainId, ecosystem.onEventBlockFilterSchema, eventItem.blockFields, eventItem.transactionFields, startBlock, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
           case "fuel" :
             if (kind !== undefined) {
               return EventConfigBuilder.buildFuelEventConfig(contractName, eventName, kind, sighash, abi, false, undefined, undefined, startBlock);
             } else {
               return Stdlib_JsError.throwWithMessage(`Fuel event ` + contractName + `.` + eventName + ` is missing "kind" in internal config`);
             }
+          case "evm" :
           case "svm" :
-            let len = addresses.length;
-            let programId = len !== 1 ? (
-                len !== 0 ? Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` has multiple addresses; a program is uniquely identified by a single program_id`) : Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` is missing a program_id`)
-              ) : 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(af => ({
-              position: af.position,
-              values: af.values
-            }));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeTransaction, svm.includeLogs, accountFilters, svm.isInner, false, undefined, undefined, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes, startBlock);
+            break;
         }
+        return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, false, undefined, undefined, undefined, chainId, ecosystem.onEventBlockFilterSchema, eventItem.blockFields, eventItem.transactionFields, startBlock, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
       });
     } else {
       return [];
@@ -553,10 +517,9 @@ function fromPublic(publicConfigJson) {
       let contractData = param[1];
       let capitalizedName = param[0];
       let chainContract = chainContracts[capitalizedName];
-      let rawAddresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []);
-      let addresses = rawAddresses.map(parseAddress);
+      let addresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []).map(parseAddress);
       let startBlock = Stdlib_Option.flatMap(chainContract, cc => cc.startBlock);
-      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock, rawAddresses, Stdlib_Option.getOr(Stdlib_Option.map(contractData.svmAbi, a => a.definedTypes), null));
+      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock);
       return {
         name: capitalizedName,
         abi: contractData.abi,
@@ -613,7 +576,6 @@ function fromPublic(publicConfigJson) {
         let rpc = publicChainConfig.rpc;
         sourceConfig = rpc !== undefined ? ({
             TAG: "SvmSourceConfig",
-            hypersync: publicChainConfig.hypersync,
             rpc: rpc
           }) : Stdlib_JsError.throwWithMessage(`Chain ` + chainName + ` is missing rpc endpoint in config`);
         break;
@@ -818,9 +780,10 @@ function canonicalJson(json) {
 }
 
 function diffPaths(stored, current) {
+  let canonEq = (a, b) => JSON.stringify(canonicalJson(a)) === JSON.stringify(canonicalJson(b));
   let acc = [];
   let go = (s, c, prefix) => {
-    if (JSON.stringify(canonicalJson(s)) === JSON.stringify(canonicalJson(c))) {
+    if (canonEq(s, c)) {
       return;
     }
     if (Array.isArray(s)) {
@@ -868,16 +831,92 @@ function diffPaths(stored, current) {
     }
     acc.push(prefix === "" ? "<root>" : prefix);
   };
-  go(stored, current, "");
+  let getTopKey = (j, k) => {
+    if (typeof j === "object" && j !== null && !Array.isArray(j)) {
+      return j[k];
+    }
+  };
+  let topKeyDiffers = k => {
+    let match = getTopKey(stored, k);
+    let match$1 = getTopKey(current, k);
+    if (match !== undefined) {
+      if (match$1 !== undefined) {
+        return !canonEq(match, match$1);
+      } else {
+        return true;
+      }
+    } else {
+      return match$1 !== undefined;
+    }
+  };
+  let runTier = keys => {
+    keys.forEach(k => {
+      let match = getTopKey(stored, k);
+      let match$1 = getTopKey(current, k);
+      if (match !== undefined) {
+        if (match$1 !== undefined) {
+          return go(match, match$1, k);
+        } else {
+          acc.push(k);
+          return;
+        }
+      } else if (match$1 !== undefined) {
+        acc.push(k);
+        return;
+      } else {
+        return;
+      }
+    });
+  };
+  if (typeof stored === "object" && stored !== null && !Array.isArray(stored) && typeof current === "object" && current !== null && !Array.isArray(current)) {
+    let tiers = [
+      ["version"],
+      ["name"],
+      ["storage"],
+      [
+        "evm",
+        "fuel",
+        "svm"
+      ],
+      ["entities"]
+    ];
+    let firstHit = Stdlib_Array.reduce(tiers, undefined, (acc, tier) => {
+      if (acc !== undefined) {
+        return acc;
+      }
+      let hits = tier.filter(topKeyDiffers);
+      if (hits.length !== 0) {
+        return hits;
+      }
+    });
+    if (firstHit !== undefined) {
+      runTier(firstHit);
+    } else {
+      let knownSet = new Set(Belt_Array.concatMany(tiers));
+      runTier(Array.from(new Set(Object.keys(stored).concat(Object.keys(current)))).filter(k => !knownSet.has(k)).toSorted(Primitive_string.compare).filter(topKeyDiffers));
+    }
+  } else {
+    go(stored, current, "");
+  }
   return acc;
 }
 
-function throwIfIncompatible(changedPaths, resetCommand) {
+function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhouse) {
   if (changedPaths.length === 0) {
     return;
   }
   let bullets = changedPaths.map(p => `    - ` + p).join("\n");
-  Stdlib_JsError.throwWithMessage(`The following config changes are incompatible with the existing indexer data:\n\n` + bullets + `\n\nPick one:\n\n  1. Revert the changes above    # resume indexing where it left off\n  2. ` + resetCommand + `                # wipe the database and re-index from scratch`);
+  let option1 = "Revert the changes above";
+  let padTo = (s, col) => s + " ".repeat(Math.max(col - s.length | 0, 1));
+  let col = Math.max(option1.length, resetCommand.length) + 2 | 0;
+  let option3;
+  if (runCommand !== undefined) {
+    let clickhouseLine = hasClickhouse ? "       ENVIO_CLICKHOUSE_DATABASE=<new_db> \\\n" : "";
+    option3 = `\n  3. Run a second indexer alongside this one — keep both datasets:\n       ENVIO_PG_SCHEMA=<new_schema> \\\n` + clickhouseLine + `       ENVIO_INDEXER_PORT=<new_port> \\\n       ` + runCommand;
+  } else {
+    option3 = "";
+  }
+  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 loadWithoutRegistrations() {
@@ -900,8 +939,6 @@ export {
   rpcConfigSchema,
   chainContractSchema,
   publicConfigChainSchema,
-  svmEventDescriptorSchema,
-  svmAbiSchema,
   contractEventItemSchema,
   contractConfigSchema,
   publicConfigEcosystemSchema,