envio 3.0.1 → 3.0.2-svm-alpha.0

package/src/Config.res

@@ -30,7 +30,7 @@ type evmRpcConfig = {
 type sourceConfig =
   | EvmSourceConfig({hypersync: option<string>, rpcs: array<evmRpcConfig>})
   | FuelSourceConfig({hypersync: string})
-  | SvmSourceConfig({rpc: string})
+  | SvmSourceConfig({hypersync: option<string>, rpc: string})
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
@@ -201,6 +201,38 @@ 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),
@@ -210,6 +242,7 @@ 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)),
   }
 )
 
@@ -219,6 +252,8 @@ 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)),
   }
 )
 
@@ -226,6 +261,10 @@ 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))),
   }
 )
 
@@ -523,10 +562,19 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => false
   }
 
-  // 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"]
+  // 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"]
   | _ => None
   }
 
@@ -549,6 +597,7 @@ 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) =>
@@ -561,21 +610,40 @@ 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"]},
+        {
+          "abi": abi,
+          "eventSignatures": eventSignatures,
+          "events": contractConfig["events"],
+          "svmAbi": widened["svmAbi"],
+        },
       )
     })
   | None => ()
   }
 
-  // Build event configs for a contract from JSON event items
+  // 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).
   let buildContractEvents = (
     ~contractName,
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
     ~startBlock: option<int>,
+    ~addresses: array<string>,
+    ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
     switch events {
     | None => []
@@ -606,6 +674,65 @@ 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,
@@ -665,11 +792,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         ->Dict.toArray
         ->Array.map(((capitalizedName, contractData)) => {
           let chainContract = chainContracts->Dict.get(capitalizedName)
-          let addresses =
+          let rawAddresses =
             chainContract
             ->Option.flatMap(cc => cc["addresses"])
             ->Option.getOr([])
-            ->Array.map(parseAddress)
+          let addresses = rawAddresses->Array.map(parseAddress)
           let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
 
           // Build event configs from JSON (field selections resolved inline)
@@ -683,6 +810,10 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~abi=contractData["abi"],
             ~chainId,
             ~startBlock,
+            ~addresses=rawAddresses,
+            ~svmDefinedTypes=contractData["svmAbi"]
+            ->Option.map(a => a["definedTypes"])
+            ->Option.getOr(JSON.Null),
           )
 
           {
@@ -748,7 +879,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
-        | Some(rpc) => SvmSourceConfig({rpc: rpc})
+        | Some(rpc) =>
+          SvmSourceConfig({
+            hypersync: publicChainConfig["hypersync"],
+            rpc,
+          })
         | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }
@@ -957,18 +1092,11 @@ let rec canonicalJson = (json: JSON.t): JSON.t =>
   }
 
 // Returns dotted leaf paths (`a.b[i].c`) where `stored` differs from
-// `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.
+// `current`. Skips subtrees whose canonical JSON matches.
 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 canonEq(s, c) {
+    if JSON.stringify(canonicalJson(s)) === JSON.stringify(canonicalJson(c)) {
       ()
     } else {
       switch (s, c) {
@@ -994,91 +1122,25 @@ let diffPaths = (~stored: JSON.t, ~current: JSON.t): array<string> => {
           | (Some(sv), Some(cv)) => go(sv, cv, p)
           }
         }
-      | _ => acc->Array.push(prefix === "" ? "<root>" : prefix)->ignore
+      | _ =>
+        // Type mismatch or scalar diff
+        acc->Array.push(prefix === "" ? "<root>" : prefix)->ignore
       }
     }
   }
-
-  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, "")
-  }
+  go(stored, current, "")
   acc
 }
 
 // Throws an `incompatible config` error listing each path in `changedPaths`,
-// 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,
-) => {
+// 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) => {
   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  1. ${option1->padTo(
-          col,
-        )}# resume indexing where it left off\n  2. ${resetCommand->padTo(
-          col,
-        )}# delete all indexed data and start over${option3}`,
+      `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`,
     )
   }
 }

package/src/Config.res.mjs

@@ -113,6 +113,26 @@ 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),
@@ -120,18 +140,21 @@ 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)))
+  transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema))),
+  svm: s.m(S$RescriptSchema.option(svmEventDescriptorSchema))
 }));
 
 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)))
+  events: s.m(S$RescriptSchema.option(S$RescriptSchema.array(contractEventItemSchema))),
+  svmAbi: s.m(S$RescriptSchema.option(svmAbiSchema))
 }));
 
 let publicConfigEcosystemSchema = S$RescriptSchema.schema(s => ({
   chains: s.m(S$RescriptSchema.dict(publicConfigChainSchema)),
-  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
+  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema))),
+  programs: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
 }));
 
 let publicConfigEvmSchema = S$RescriptSchema.schema(s => ({
@@ -419,6 +442,7 @@ 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" :
@@ -428,25 +452,25 @@ function fromPublic(publicConfigJson) {
       publicContractsConfig = match$5 !== undefined ? Primitive_option.valFromOption(match$5).contracts : undefined;
       break;
     case "svm" :
-      publicContractsConfig = undefined;
+      publicContractsConfig = match$6 !== undefined ? Primitive_option.valFromOption(match$6).programs : undefined;
       break;
   }
   let evm$1 = publicConfig.evm;
-  let match$6;
+  let match$7;
   if (evm$1 !== undefined) {
     let evm$2 = Primitive_option.valFromOption(evm$1);
-    match$6 = [
+    match$7 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields.concat(Stdlib_Option.getOr(evm$2.globalBlockFields, []))),
       new Set(Stdlib_Option.getOr(evm$2.globalTransactionFields, []))
     ];
   } else {
-    match$6 = [
+    match$7 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields),
       new Set()
     ];
   }
-  let globalTransactionFieldsSet = match$6[1];
-  let globalBlockFieldsSet = match$6[0];
+  let globalTransactionFieldsSet = match$7[1];
+  let globalBlockFieldsSet = match$7[0];
   let contractDataByName = {};
   if (publicContractsConfig !== undefined) {
     Object.entries(publicContractsConfig).forEach(param => {
@@ -458,11 +482,13 @@ function fromPublic(publicConfigJson) {
       contractDataByName[capitalizedName] = {
         abi: abi,
         eventSignatures: eventSignatures,
-        events: contractConfig.events
+        events: contractConfig.events,
+        svmAbi: contractConfig.svmAbi
       };
     });
   }
-  let buildContractEvents = (contractName, events, abi, chainId, startBlock) => {
+  let buildContractEvents = (contractName, events, abi, chainId, startBlock, addresses, svmDefinedTypesOpt) => {
+    let svmDefinedTypes = svmDefinedTypesOpt !== undefined ? svmDefinedTypesOpt : null;
     if (events !== undefined) {
       return events.map(eventItem => {
         let eventName = eventItem.name;
@@ -470,17 +496,27 @@ 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" :
-            break;
+            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);
         }
-        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 [];
@@ -517,9 +553,10 @@ function fromPublic(publicConfigJson) {
       let contractData = param[1];
       let capitalizedName = param[0];
       let chainContract = chainContracts[capitalizedName];
-      let addresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []).map(parseAddress);
+      let rawAddresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []);
+      let addresses = rawAddresses.map(parseAddress);
       let startBlock = Stdlib_Option.flatMap(chainContract, cc => cc.startBlock);
-      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock);
+      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock, rawAddresses, Stdlib_Option.getOr(Stdlib_Option.map(contractData.svmAbi, a => a.definedTypes), null));
       return {
         name: capitalizedName,
         abi: contractData.abi,
@@ -576,6 +613,7 @@ 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;
@@ -780,10 +818,9 @@ 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 (canonEq(s, c)) {
+    if (JSON.stringify(canonicalJson(s)) === JSON.stringify(canonicalJson(c))) {
       return;
     }
     if (Array.isArray(s)) {
@@ -831,92 +868,16 @@ function diffPaths(stored, current) {
     }
     acc.push(prefix === "" ? "<root>" : prefix);
   };
-  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, "");
-  }
+  go(stored, current, "");
   return acc;
 }
 
-function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhouse) {
+function throwIfIncompatible(changedPaths, resetCommand) {
   if (changedPaths.length === 0) {
     return;
   }
   let bullets = changedPaths.map(p => `    - ` + p).join("\n");
-  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);
+  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`);
 }
 
 function loadWithoutRegistrations() {
@@ -939,6 +900,8 @@ export {
   rpcConfigSchema,
   chainContractSchema,
   publicConfigChainSchema,
+  svmEventDescriptorSchema,
+  svmAbiSchema,
   contractEventItemSchema,
   contractConfigSchema,
   publicConfigEcosystemSchema,