envio 3.0.2-svm-alpha.0 → 3.0.2

package/src/Core.res

@@ -4,41 +4,9 @@
 
 // NAPI encodes Rust `Option<T>` as `null | T` (never `undefined`), so the
 // tighter `Null.t` captures the exact boundary shape.
-//
-// Opaque carriers for the NAPI class constructors. Static factories
-// (`newWithAgent`, `fromConfig`, `fromSignatures`) hang off these via `@send`
-// in `HyperSyncClient.res` / `HyperSyncSolanaClient.res`.
-type hypersyncClientCtor
-type hypersyncSolanaClientCtor
-type decoderCtor
-
-/// JS shape of one decoded instruction. Mirrors `DecodedInstructionJson` in
-/// `packages/cli/src/hypersync_source_svm/decoder.rs`. The `argsJson` /
-/// `accountsJson` fields are stringified to side-step napi-rs's lack of
-/// native `serde_json::Value` passthrough; callers `JSON.parse` once.
-type svmDecodedInstruction = {
-  name: string,
-  argsJson: string,
-  accountsJson: string,
-  extraAccounts: array<string>,
-}
-
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
   runCli: (~args: array<string>, ~envioPackageDir: Null.t<string>) => promise<Null.t<string>>,
-  @as("HypersyncClient")
-  hypersyncClient: hypersyncClientCtor,
-  @as("HypersyncSolanaClient")
-  hypersyncSolanaClient: hypersyncSolanaClientCtor,
-  @as("Decoder")
-  decoder: decoderCtor,
-  setLogLevel: string => unit,
-  registerProgramSchema: (~descriptorJson: string) => int,
-  decodeInstruction: (
-    ~schemaHandle: int,
-    ~dataHex: string,
-    ~accounts: array<string>,
-  ) => Null.t<svmDecodedInstruction>,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/Env.res.mjs

@@ -7,6 +7,7 @@ import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as HypersyncClient from "@envio-dev/hypersync-client";
 
 import 'dotenv/config'
 ;
@@ -61,7 +62,7 @@ let hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CL
 
 let hypersyncLogLevel = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_LOG_LEVEL", HyperSyncClient.logLevelSchema, undefined, "info", undefined, undefined);
 
-HyperSyncClient.setLogLevel(hypersyncLogLevel);
+HypersyncClient.setLogLevel(hypersyncLogLevel);
 
 let logStrategy = EnvSafe.get(envSafe, "LOG_STRATEGY", S$RescriptSchema.$$enum([
   "ecs-file",

package/src/Envio.res

@@ -20,100 +20,6 @@ type svmOnSlotArgs<'context> = {
   context: 'context,
 }
 
-/** Borsh-decoded instruction view. Present whenever a `ProgramSchema` was
- attached to the program (bundled schema, Anchor IDL, or hand-written YAML
- `accounts`/`args`). Absent (`None`) when no schema applied or the
- discriminator didn't match any registered instruction. */
-type svmDecodedInstruction = {
-  /** Schema-declared instruction name (matches the codegen module suffix). */
-  name: string,
-  /** Borsh-decoded args. `JSON.Object({})` for no-arg instructions
-   (e.g. `VerifyCollection`). POC types this as raw `JSON.t`; cast at the
-   handler with `(json :> MyArgsType)` until typed codegen lands. */
-  args: JSON.t,
-  /** Named accounts in schema order. Keys are exactly the schema-declared
-   names; values are base58 pubkey strings. */
-  accounts: dict<string>,
-  /** Accounts beyond the schema's named list (Anchor `remaining_accounts`,
-   IDL drift). `[]` when counts match. */
-  extraAccounts: array<string>,
-}
-
-type svmInstruction = {
-  programId: SvmTypes.Pubkey.t,
-  /** Raw instruction bytes as `0x`-prefixed hex. */
-  data: string,
-  accounts: array<SvmTypes.Pubkey.t>,
-  /** Path through the call tree: `[outerIndex]` for top-level instructions,
-   appended child indices for inner CPI calls. */
-  instructionAddress: array<int>,
-  isInner: bool,
-  /** Discriminator prefixes pre-extracted by HyperSync. Each is `Some` only
-   when the underlying instruction is at least that long. */
-  d1?: string,
-  d2?: string,
-  d4?: string,
-  d8?: string,
-  /** Borsh-decoded view. See [[svmDecodedInstruction]]. */
-  decoded?: svmDecodedInstruction,
-}
-
-type svmTransaction = {
-  signatures: array<string>,
-  feePayer?: SvmTypes.Pubkey.t,
-  success?: bool,
-  err?: string,
-  fee?: bigint,
-  computeUnitsConsumed?: bigint,
-  accountKeys: array<SvmTypes.Pubkey.t>,
-  recentBlockhash?: string,
-  version?: string,
-}
-
-type svmLog = {
-  kind: string,
-  message: string,
-}
-
-/** Inner block record on `svmInstructionEvent`. Field names follow EVM/Fuel
- (`height`, `time`, `hash`) so the shared `Ecosystem.t` getters in
- `Svm.res` work uniformly across ecosystems — `height` carries the slot. */
-type svmInstructionEventBlock = {
-  /** Slot number. Named `height` so the shared ecosystem getter reads it. */
-  height: int,
-  /** Unix block time (seconds). `0` when HyperSync didn't return a block
-   for this instruction's slot. */
-  time: int,
-  /** Block hash. Currently always empty — populated by the future
-   reorg-guard `queryBlockHash(slot)` route. */
-  hash: string,
-}
-
-/** The per-instruction payload handlers receive on `.event`. Mirrors the
- EVM `type event` shape inside generated per-event modules. */
-type svmInstructionEvent = {
-  contractName: string,
-  eventName: string,
-  instruction: svmInstruction,
-  /** Parent transaction. `None` when the per-instruction
-   `include_transaction` flag is `false`. */
-  transaction: option<svmTransaction>,
-  /** Program log entries scoped to this instruction. `None` when the
-   per-instruction `include_logs` flag is `false`. */
-  logs: option<array<svmLog>>,
-  /** Convenience alias for `block.height`. */
-  slot: int,
-  /** Convenience alias for `block.time`. */
-  blockTime: option<int>,
-  block: svmInstructionEventBlock,
-}
-
-/** Arguments passed to handlers registered via `indexer.onInstruction`. */
-type svmOnInstructionArgs<'context> = {
-  event: svmInstructionEvent,
-  context: 'context,
-}
-
 // Internal-only type for the `indexer.onBlock` (and SVM `onSlot`) `where`
 // callback argument. The canonical TypeScript shape lives in
 // `packages/envio/index.d.ts`; the ReScript declaration here is free to

package/src/EventConfigBuilder.res

@@ -142,25 +142,28 @@ let rec abiTypeToDefaultValue = (abiType: string): unknown => {
 
 // ============== Named-tuple (struct) schema helpers ==============
 
-// Build a simulate schema that honours component names: whenever an event param
-// (or nested field) has components, we decode it as an object with named fields
-// rather than a positional tuple. Walks through array wrappers so `struct[]`
-// still produces `array<{...}>`.
-let rec componentsToSimulateSchema = (abiType: string, components: array<eventParamComponent>): S.t<
-  unknown,
-> => {
+// Build an object schema that honours component names: whenever an event param
+// (or nested field) has components, decode/serialize it as an object with
+// named fields rather than a positional tuple. Walks through array wrappers so
+// `struct[]` still produces `array<{...}>`. `~leafSchema` picks the per-ABI
+// schema for non-tuple leaves (raw-event vs simulate variants differ in how
+// they accept primitives — string-encoded numbers vs native bigints).
+let rec componentsToObjectSchema = (
+  ~leafSchema: string => S.t<unknown>,
+  abiType: string,
+  components: array<eventParamComponent>,
+): S.t<unknown> => {
   if abiType->String.endsWith("]") {
     let bracketIdx = abiType->String.lastIndexOf("[")
     let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
-    S.array(componentsToSimulateSchema(baseType, components))->S.toUnknown
+    S.array(componentsToObjectSchema(~leafSchema, baseType, components))->S.toUnknown
   } else {
-    // Must be a tuple at this level: build a record keyed by component names.
     S.object(s => {
       let dict = Dict.make()
       components->Array.forEach(c => {
         let childSchema = switch c.components {
-        | Some(sub) => componentsToSimulateSchema(c.abiType, sub)
-        | None => abiTypeToSimulateSchema(c.abiType)
+        | Some(sub) => componentsToObjectSchema(~leafSchema, c.abiType, sub)
+        | None => leafSchema(c.abiType)
         }
         dict->Dict.set(c.name, s.field(c.name, childSchema))
       })
@@ -233,7 +236,16 @@ let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> =
     S.object(s => {
       let dict = Dict.make()
       params->Array.forEach(p => {
-        dict->Dict.set(p.name, s.field(p.name, abiTypeToSchema(p.abiType)))
+        // Indexed structs arrive as keccak256 topic hashes (single hex
+        // strings), so they keep the positional/leaf path; only non-indexed
+        // tuple params get the named-object shape that the HyperSync decoder
+        // (componentsToRemapper) produces.
+        let paramSchema = switch p.components {
+        | Some(components) if !p.indexed =>
+          componentsToObjectSchema(~leafSchema=abiTypeToSchema, p.abiType, components)
+        | _ => abiTypeToSchema(p.abiType)
+        }
+        dict->Dict.set(p.name, s.field(p.name, paramSchema))
       })
       dict
     })->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.eventParams>)
@@ -255,7 +267,7 @@ let buildSimulateParamsSchema = (params: array<eventParam>): S.t<Internal.eventP
       params->Array.forEach(p => {
         let (paramSchema, paramDefault) = switch p.components {
         | Some(components) => (
-            componentsToSimulateSchema(p.abiType, components),
+            componentsToObjectSchema(~leafSchema=abiTypeToSimulateSchema, p.abiType, components),
             componentsToDefaultValue(p.abiType, components),
           )
         | None => (abiTypeToSimulateSchema(p.abiType), abiTypeToDefaultValue(p.abiType))
@@ -484,56 +496,6 @@ let buildEvmEventConfig = (
 
 // ============== Build Fuel event config ==============
 
-let buildSvmInstructionEventConfig = (
-  ~contractName: string,
-  ~instructionName: string,
-  ~programId: SvmTypes.Pubkey.t,
-  ~discriminator: option<string>,
-  ~discriminatorByteLen: int,
-  ~includeTransaction: bool,
-  ~includeLogs: bool,
-  ~accountFilters: array<Internal.svmAccountFilter>,
-  ~isInner: option<bool>,
-  ~isWildcard: bool,
-  ~handler: option<Internal.handler>,
-  ~contractRegister: option<Internal.contractRegister>,
-  ~accounts: array<string>=[],
-  ~args: JSON.t=JSON.Null,
-  ~definedTypes: JSON.t=JSON.Null,
-  ~startBlock: option<int>=?,
-): Internal.svmInstructionEventConfig => {
-  let paramsSchema =
-    S.json(~validate=false)
-    ->Utils.Schema.coerceToJsonPgType
-    ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
-  {
-    id: switch discriminator {
-    | Some(d) => d
-    | None => "none"
-    },
-    name: instructionName,
-    contractName,
-    isWildcard,
-    handler,
-    contractRegister,
-    paramsRawEventSchema: paramsSchema,
-    simulateParamsSchema: paramsSchema,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    startBlock,
-    programId,
-    discriminator,
-    discriminatorByteLen,
-    includeTransaction,
-    includeLogs,
-    accountFilters,
-    isInner,
-    accounts,
-    args,
-    definedTypes,
-  }
-}
-
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,

package/src/EventConfigBuilder.res.mjs

@@ -144,13 +144,13 @@ function abiTypeToDefaultValue(abiType) {
   }
 }
 
-function componentsToSimulateSchema(abiType, components) {
+function componentsToObjectSchema(leafSchema, abiType, components) {
   if (!abiType.endsWith("]")) {
     return S$RescriptSchema.object(s => {
       let dict = {};
       components.forEach(c => {
         let sub = c.components;
-        let childSchema = sub !== undefined ? componentsToSimulateSchema(c.abiType, sub) : abiTypeToSimulateSchema(c.abiType);
+        let childSchema = sub !== undefined ? componentsToObjectSchema(leafSchema, c.abiType, sub) : leafSchema(c.abiType);
         dict[c.name] = s.f(c.name, childSchema);
       });
       return dict;
@@ -158,7 +158,7 @@ function componentsToSimulateSchema(abiType, components) {
   }
   let bracketIdx = abiType.lastIndexOf("[");
   let baseType = abiType.slice(0, bracketIdx);
-  return S$RescriptSchema.array(componentsToSimulateSchema(baseType, components));
+  return S$RescriptSchema.array(componentsToObjectSchema(leafSchema, baseType, components));
 }
 
 function componentsToDefaultValue(abiType, components) {
@@ -197,7 +197,9 @@ function buildParamsSchema(params) {
     return S$RescriptSchema.object(s => {
       let dict = {};
       params.forEach(p => {
-        dict[p.name] = s.f(p.name, abiTypeToSchema(p.abiType));
+        let components = p.components;
+        let paramSchema = components !== undefined && !p.indexed ? componentsToObjectSchema(abiTypeToSchema, p.abiType, components) : abiTypeToSchema(p.abiType);
+        dict[p.name] = s.f(p.name, paramSchema);
       });
       return dict;
     });
@@ -213,7 +215,7 @@ function buildSimulateParamsSchema(params) {
       params.forEach(p => {
         let components = p.components;
         let match = components !== undefined ? [
-            componentsToSimulateSchema(p.abiType, components),
+            componentsToObjectSchema(abiTypeToSimulateSchema, p.abiType, components),
             componentsToDefaultValue(p.abiType, components)
           ] : [
             abiTypeToSimulateSchema(p.abiType),
@@ -350,36 +352,6 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   };
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
-  let accounts = accountsOpt !== undefined ? accountsOpt : [];
-  let args = argsOpt !== undefined ? argsOpt : null;
-  let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
-  let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
-  return {
-    id: discriminator !== undefined ? discriminator : "none",
-    name: instructionName,
-    contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    handler: handler,
-    contractRegister: contractRegister,
-    paramsRawEventSchema: paramsSchema,
-    simulateParamsSchema: paramsSchema,
-    startBlock: startBlock,
-    programId: programId,
-    discriminator: discriminator,
-    discriminatorByteLen: discriminatorByteLen,
-    includeTransaction: includeTransaction,
-    includeLogs: includeLogs,
-    accountFilters: accountFilters,
-    isInner: isInner,
-    accounts: accounts,
-    args: args,
-    definedTypes: definedTypes
-  };
-}
-
 function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
   let fuelKind;
   switch (kind) {
@@ -447,7 +419,7 @@ export {
   abiTypeToSchema,
   abiTypeToSimulateSchema,
   abiTypeToDefaultValue,
-  componentsToSimulateSchema,
+  componentsToObjectSchema,
   componentsToDefaultValue,
   componentsToRemapper,
   buildParamsSchema,
@@ -458,7 +430,6 @@ export {
   alwaysIncludedBlockFields,
   resolveFieldSelection,
   buildEvmEventConfig,
-  buildSvmInstructionEventConfig,
   buildFuelEventConfig,
 }
 /* eventParamComponentSchema Not a pure module */

package/src/HandlerLoader.res

@@ -142,18 +142,7 @@ let applyRegistrations = (~config: Config.t): Config.t => {
               dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
             } :> Internal.eventConfig)
           | Svm =>
-            let svmEv =
-              ev->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
-            ({
-              ...svmEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              dependsOnAddresses: Internal.dependsOnAddresses(
-                ~isWildcard,
-                ~filterByAddresses=false,
-              ),
-            } :> Internal.eventConfig)
+            JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`)
           }
         },
       )

package/src/HandlerLoader.res.mjs

@@ -109,12 +109,7 @@ function applyRegistrations(config) {
               kind: ev.kind
             };
           case "svm" :
-            let newrecord = {...ev};
-            newrecord.contractRegister = contractRegister;
-            newrecord.handler = handler;
-            newrecord.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
-            newrecord.isWildcard = isWildcard;
-            return newrecord;
+            return Stdlib_JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`);
         }
       });
       return {

package/src/Internal.res

@@ -422,44 +422,6 @@ type evmContractConfig = {
   events: array<evmEventConfig>,
 }
 
-type svmAccountFilter = {
-  position: int,
-  values: array<SvmTypes.Pubkey.t>,
-}
-
-type svmInstructionEventConfig = {
-  ...eventConfig,
-  /** Base58 Solana program id this instruction belongs to. */
-  programId: SvmTypes.Pubkey.t,
-  /** Hex-encoded discriminator. `None` matches every instruction in the program. */
-  discriminator: option<string>,
-  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
-   `dN` selector at query time and the dispatch-key precomputation in the
-   router. */
-  discriminatorByteLen: int,
-  includeTransaction: bool,
-  includeLogs: bool,
-  accountFilters: array<svmAccountFilter>,
-  /** `None` matches both outer and inner (CPI-invoked) instructions. */
-  isInner: option<bool>,
-  /** Positional account names from the Borsh schema, in declared order.
-   `[]` means no schema is attached for this instruction. */
-  accounts: array<string>,
-  /** Borsh args layout as `Vec<ArgDef>` JSON (see `human_config::svm::ArgDef`
-   on the Rust side). `JSON.Null` means no schema is attached. */
-  args: JSON.t,
-  /** Program-level nominal-type registry (`BTreeMap<String, ArgType>` JSON).
-   Duplicated on every event of the same program — the runtime dedups by
-   `programId` when registering. `JSON.Null` when empty. */
-  definedTypes: JSON.t,
-}
-
-type svmProgramConfig = {
-  name: string,
-  programId: SvmTypes.Pubkey.t,
-  instructions: array<svmInstructionEventConfig>,
-}
-
 type indexingAddress = {
   address: Address.t,
   contractName: string,

package/src/Main.res

@@ -298,57 +298,6 @@ let getGlobalIndexer = (): 'indexer => {
     )
   }
 
-  // SVM identity: `{program, instruction}` from TS or
-  // `{instruction: GADT{contract, _0}}` from ReScript. Same two-format dance
-  // as the EVM `parseIdentityConfig`, but reading the SVM-native field names.
-  let parseSvmIdentityConfig = (identityConfig: 'a) => {
-    let raw =
-      identityConfig->(
-        Utils.magic: 'a => {
-          "program": unknown,
-          "instruction": unknown,
-          "where": option<JSON.t>,
-        }
-      )
-    let (programName, instructionName) = if typeof(raw["program"]) === #string {
-      (
-        raw["program"]->(Utils.magic: unknown => string),
-        raw["instruction"]->(Utils.magic: unknown => string),
-      )
-    } else {
-      let inst =
-        raw["instruction"]->(Utils.magic: unknown => {"contract": string, "_0": string})
-      (inst["contract"], inst["_0"])
-    }
-    let where = raw["where"]
-    let eventOptions: option<Internal.eventOptions<_>> = switch where {
-    | None => None
-    | Some(_) =>
-      Some({
-        where: ?(where->(Utils.magic: option<JSON.t> => option<_>)),
-      })
-    }
-    (programName, instructionName, eventOptions)
-  }
-
-  // onInstruction: delegates to HandlerRegister.setHandler. The SVM analog of
-  // onEvent; the registration store keys on `(contractName, eventName)` which
-  // for SVM is `(programName, instructionName)`.
-  let onInstructionFn = (identityConfig: 'a, handler: 'b) => {
-    HandlerRegister.throwIfFinishedRegistration(~methodName="onInstruction")
-    let (programName, instructionName, eventOptions) = parseSvmIdentityConfig(identityConfig)
-    HandlerRegister.setHandler(
-      ~contractName=programName,
-      ~eventName=instructionName,
-      handler->(
-        Utils.magic: 'b => Internal.genericHandler<
-          Internal.genericHandlerArgs<Internal.event, Internal.handlerContext>,
-        >
-      ),
-      ~eventOptions,
-    )
-  }
-
   // contractRegister: delegates to HandlerRegister.setContractRegister
   let contractRegisterFn = (identityConfig: 'a, handler: 'b) => {
     HandlerRegister.throwIfFinishedRegistration(~methodName="contractRegister")
@@ -507,7 +456,7 @@ let getGlobalIndexer = (): 'indexer => {
             "contractRegister",
             "onBlock",
           ]
-        | Svm => ["name", "description", "chainIds", "chains", "onInstruction", "onSlot"]
+        | Svm => ["name", "description", "chainIds", "chains", "onSlot"]
         }
         keysMemo := Some(keys)
         keys
@@ -528,7 +477,6 @@ let getGlobalIndexer = (): 'indexer => {
         chains->(Utils.magic: {..} => unknown)
       }
     | "onEvent" => onEventFn->Utils.magic
-    | "onInstruction" => onInstructionFn->Utils.magic
     | "contractRegister" => contractRegisterFn->Utils.magic
     | "onBlock" | "onSlot" => onBlockFn->Utils.magic
     | _ =>
@@ -674,6 +622,7 @@ let migrate = async (~reset) => {
     ~chainConfigs=config.chainMap->ChainMap.values,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand="envio local db-migrate setup",
+    ~runCommand=None,
   )
   await persistence.storage.close()
 }
@@ -720,6 +669,7 @@ let start = async (
     ~chainConfigs=configWithoutRegistrations.chainMap->ChainMap.values,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand=isDevelopmentMode ? "envio dev -r" : "envio start -r",
+    ~runCommand=Some(isDevelopmentMode ? "envio dev" : "envio start"),
   )
 
   // `Config.loadWithoutRegistrations` never sees registration state; handler,

package/src/Main.res.mjs

@@ -249,35 +249,6 @@ function getGlobalIndexer() {
     let match = parseIdentityConfig(identityConfig);
     HandlerRegister.setHandler(match[0], match[1], handler, match[2], undefined);
   };
-  let parseSvmIdentityConfig = identityConfig => {
-    let match;
-    if (typeof identityConfig.program === "string") {
-      match = [
-        identityConfig.program,
-        identityConfig.instruction
-      ];
-    } else {
-      let inst = identityConfig.instruction;
-      match = [
-        inst.contract,
-        inst._0
-      ];
-    }
-    let where = identityConfig.where;
-    let eventOptions = where !== undefined ? ({
-        where: where
-      }) : undefined;
-    return [
-      match[0],
-      match[1],
-      eventOptions
-    ];
-  };
-  let onInstructionFn = (identityConfig, handler) => {
-    HandlerRegister.throwIfFinishedRegistration("onInstruction");
-    let match = parseSvmIdentityConfig(identityConfig);
-    HandlerRegister.setHandler(match[0], match[1], handler, match[2], undefined);
-  };
   let contractRegisterFn = (identityConfig, handler) => {
     HandlerRegister.throwIfFinishedRegistration("contractRegister");
     let match = parseIdentityConfig(identityConfig);
@@ -369,7 +340,6 @@ function getGlobalIndexer() {
           "description",
           "chainIds",
           "chains",
-          "onInstruction",
           "onSlot"
         ];
         break;
@@ -402,8 +372,6 @@ function getGlobalIndexer() {
         return Config.loadWithoutRegistrations().name;
       case "onEvent" :
         return onEventFn;
-      case "onInstruction" :
-        return onInstructionFn;
       case "onBlock" :
       case "onSlot" :
         return onBlockFn;
@@ -504,7 +472,7 @@ function getEnvioInfo() {
 async function migrate(reset) {
   let config = Config.loadWithoutRegistrations();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", reset);
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset);
   return await persistence.storage.close();
 }
 
@@ -529,7 +497,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let isDevelopmentMode = !isTest && configWithoutRegistrations.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(configWithoutRegistrations, undefined);
   globalPersistenceRef.contents = persistence$1;
-  await Persistence.init(persistence$1, ChainMap.values(configWithoutRegistrations.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", reset);
+  await Persistence.init(persistence$1, ChainMap.values(configWithoutRegistrations.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
   let match = await HandlerLoader.registerAllHandlers(configWithoutRegistrations);
   let registrations = match[1];
   let config = match[0];

package/src/Persistence.res

@@ -168,7 +168,7 @@ let make = (
 }
 
 let init = {
-  async (persistence, ~chainConfigs, ~envioInfo, ~resetCommand, ~reset=false) => {
+  async (persistence, ~chainConfigs, ~envioInfo, ~resetCommand, ~runCommand, ~reset=false) => {
     try {
       let shouldRun = switch persistence.storageStatus {
       | Unknown => true
@@ -212,7 +212,22 @@ let init = {
           | None => ["envio info is missing — storage initialized by an older envio"]
           | Some(stored) => Config.diffPaths(~stored, ~current=envioInfo)
           }
-          Config.throwIfIncompatible(changedPaths, ~resetCommand)
+          // `storage.clickhouse` is serialized as a plain bool by the
+          // public config (see Rust `StorageConfig`), so probe for
+          // `Boolean(true)`, not an object.
+          let hasClickhouse = switch envioInfo {
+          | Object(d) =>
+            switch d->Dict.get("storage") {
+            | Some(Object(s)) =>
+              switch s->Dict.get("clickhouse") {
+              | Some(Boolean(true)) => true
+              | _ => false
+              }
+            | _ => false
+            }
+          | _ => false
+          }
+          Config.throwIfIncompatible(changedPaths, ~resetCommand, ~runCommand, ~hasClickhouse)
           persistence.storageStatus = Ready(initialState)
           let progress = Dict.make()
           initialState.chains->Array.forEach(c => {