envio 3.0.1 → 3.0.2-svm-alpha.1

package/src/Core.res

@@ -4,9 +4,41 @@
 
 // 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,7 +7,6 @@ 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'
 ;
@@ -62,7 +61,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,6 +20,109 @@ 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 svmTokenBalance = {
+  account?: SvmTypes.Pubkey.t,
+  mint?: SvmTypes.Pubkey.t,
+  owner?: SvmTypes.Pubkey.t,
+  preAmount?: string,
+  postAmount?: string,
+}
+
+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,
+  tokenBalances?: array<svmTokenBalance>,
+}
+
+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

@@ -484,6 +484,58 @@ 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,
+  ~includeTokenBalances: 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,
+    includeTokenBalances,
+    accountFilters,
+    isInner,
+    accounts,
+    args,
+    definedTypes,
+  }
+}
+
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,

package/src/EventConfigBuilder.res.mjs

@@ -350,6 +350,37 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   };
 }
 
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, includeTokenBalances, 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,
+    includeTokenBalances: includeTokenBalances,
+    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) {
@@ -428,6 +459,7 @@ export {
   alwaysIncludedBlockFields,
   resolveFieldSelection,
   buildEvmEventConfig,
+  buildSvmInstructionEventConfig,
   buildFuelEventConfig,
 }
 /* eventParamComponentSchema Not a pure module */

package/src/HandlerLoader.res

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

package/src/HandlerLoader.res.mjs

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

package/src/Hasura.res

@@ -40,6 +40,19 @@ let clearMetadataRoute = Rest.route(() => {
   responses,
 })
 
+let reloadMetadataRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    let _ = s.field("type", S.literal("reload_metadata"))
+    {
+      "args": s.field("args", S.json(~validate=false)),
+      "auth": s->auth,
+    }
+  },
+  responses,
+})
+
 let trackTablesRoute = Rest.route(() => {
   method: Post,
   path: "",
@@ -110,6 +123,31 @@ let clearHasuraMetadata = async (~endpoint, ~auth) => {
   }
 }
 
+let reloadHasuraMetadata = async (~endpoint, ~auth) => {
+  try {
+    let result = await reloadMetadataRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "args": {
+          "reload_sources": ["default"],
+        }->(Utils.magic: 'a => JSON.t),
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => "Hasura metadata reloaded"
+    | AlreadyDone => "Hasura metadata reload acknowledged"
+    }
+    Logging.trace(msg)
+  } catch {
+  | exn =>
+    Logging.error({
+      "msg": `There was an issue reloading hasura metadata - table tracking may race with schema creation.`,
+      "err": exn->Utils.prettifyExn,
+    })
+  }
+}
+
 let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>) => {
   try {
     let result = await trackTablesRoute->Rest.fetch(
@@ -242,6 +280,11 @@ let trackDatabase = async (
 
   let _ = await clearHasuraMetadata(~endpoint, ~auth)
 
+  // Force Hasura to re-introspect the source schema before tracking, otherwise
+  // freshly-created user tables may be invisible to pg_track_tables and the call
+  // returns `metadata-warnings` (HTTP 400), leaving tracking permanently broken.
+  await reloadHasuraMetadata(~endpoint, ~auth)
+
   await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
 
   for i in 0 to tableNames->Array.length - 1 {

package/src/Hasura.res.mjs

@@ -46,6 +46,21 @@ function clearMetadataRoute() {
   };
 }
 
+function reloadMetadataRoute() {
+  return {
+    method: "POST",
+    path: "",
+    input: s => {
+      s.field("type", S$RescriptSchema.literal("reload_metadata"));
+      return {
+        args: s.field("args", S$RescriptSchema.json(false)),
+        auth: auth(s)
+      };
+    },
+    responses: responses
+  };
+}
+
 function trackTablesRoute() {
   return {
     method: "POST",
@@ -112,6 +127,26 @@ async function clearHasuraMetadata(endpoint, auth) {
   }
 }
 
+async function reloadHasuraMetadata(endpoint, auth) {
+  try {
+    let result = await Rest.fetch(reloadMetadataRoute, {
+      auth: auth,
+      args: {
+        reload_sources: ["default"]
+      }
+    }, Rest.client(endpoint, undefined));
+    let tmp;
+    tmp = result === "QuerySucceeded" ? "Hasura metadata reloaded" : "Hasura metadata reload acknowledged";
+    return Logging.trace(tmp);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Logging.error({
+      msg: `There was an issue reloading hasura metadata - table tracking may race with schema creation.`,
+      err: Utils.prettifyExn(exn)
+    });
+  }
+}
+
 async function trackTables(endpoint, auth, pgSchema, tableNames) {
   try {
     let result = await Rest.fetch(trackTablesRoute, {
@@ -202,6 +237,7 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
   ]);
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
+  await reloadHasuraMetadata(endpoint, auth);
   await trackTables(endpoint, auth, pgSchema, tableNames);
   for (let i = 0, i_finish = tableNames.length; i < i_finish; ++i) {
     let tableName = tableNames[i];
@@ -231,10 +267,12 @@ export {
   auth,
   responses,
   clearMetadataRoute,
+  reloadMetadataRoute,
   trackTablesRoute,
   rawBodyRoute,
   sendOperation,
   clearHasuraMetadata,
+  reloadHasuraMetadata,
   trackTables,
   createSelectPermission,
   createEntityRelationship,

package/src/Internal.res

@@ -422,6 +422,45 @@ 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,
+  includeTokenBalances: 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,6 +298,57 @@ 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")
@@ -456,7 +507,7 @@ let getGlobalIndexer = (): 'indexer => {
             "contractRegister",
             "onBlock",
           ]
-        | Svm => ["name", "description", "chainIds", "chains", "onSlot"]
+        | Svm => ["name", "description", "chainIds", "chains", "onInstruction", "onSlot"]
         }
         keysMemo := Some(keys)
         keys
@@ -477,6 +528,7 @@ let getGlobalIndexer = (): 'indexer => {
         chains->(Utils.magic: {..} => unknown)
       }
     | "onEvent" => onEventFn->Utils.magic
+    | "onInstruction" => onInstructionFn->Utils.magic
     | "contractRegister" => contractRegisterFn->Utils.magic
     | "onBlock" | "onSlot" => onBlockFn->Utils.magic
     | _ =>
@@ -622,7 +674,6 @@ let migrate = async (~reset) => {
     ~chainConfigs=config.chainMap->ChainMap.values,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand="envio local db-migrate setup",
-    ~runCommand=None,
   )
   await persistence.storage.close()
 }
@@ -669,7 +720,6 @@ 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,6 +249,35 @@ 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);
@@ -340,6 +369,7 @@ function getGlobalIndexer() {
           "description",
           "chainIds",
           "chains",
+          "onInstruction",
           "onSlot"
         ];
         break;
@@ -372,6 +402,8 @@ function getGlobalIndexer() {
         return Config.loadWithoutRegistrations().name;
       case "onEvent" :
         return onEventFn;
+      case "onInstruction" :
+        return onInstructionFn;
       case "onBlock" :
       case "onSlot" :
         return onBlockFn;
@@ -472,7 +504,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", undefined, reset);
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", reset);
   return await persistence.storage.close();
 }
 
@@ -497,7 +529,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", isDevelopmentMode ? "envio dev" : "envio start", reset);
+  await Persistence.init(persistence$1, ChainMap.values(configWithoutRegistrations.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", 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, ~runCommand, ~reset=false) => {
+  async (persistence, ~chainConfigs, ~envioInfo, ~resetCommand, ~reset=false) => {
     try {
       let shouldRun = switch persistence.storageStatus {
       | Unknown => true
@@ -212,22 +212,7 @@ let init = {
           | None => ["envio info is missing — storage initialized by an older envio"]
           | Some(stored) => Config.diffPaths(~stored, ~current=envioInfo)
           }
-          // `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)
+          Config.throwIfIncompatible(changedPaths, ~resetCommand)
           persistence.storageStatus = Ready(initialState)
           let progress = Dict.make()
           initialState.chains->Array.forEach(c => {