envio 3.0.1 → 3.0.2-svm-alpha.0

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,100 @@ 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

@@ -484,6 +484,56 @@ 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

@@ -350,6 +350,36 @@ 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) {
@@ -428,6 +458,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/Internal.res

@@ -422,6 +422,44 @@ 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,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 => {

package/src/Persistence.res.mjs

@@ -27,7 +27,7 @@ function make(userEntities, allEnums, storage) {
   };
 }
 
-async function init(persistence, chainConfigs, envioInfo, resetCommand, runCommand, resetOpt) {
+async function init(persistence, chainConfigs, envioInfo, resetCommand, resetOpt) {
   let reset = resetOpt !== undefined ? resetOpt : false;
   try {
     let promise = persistence.storageStatus;
@@ -70,19 +70,7 @@ async function init(persistence, chainConfigs, envioInfo, resetCommand, runComma
         let initialState$1 = await persistence.storage.resumeInitialState();
         let stored = initialState$1.envioInfo;
         let changedPaths = stored !== undefined ? Config.diffPaths(stored, envioInfo) : ["envio info is missing — storage initialized by an older envio"];
-        let hasClickhouse;
-        if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
-          let match$1 = envioInfo["storage"];
-          if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
-            let match$2 = match$1["clickhouse"];
-            hasClickhouse = match$2 === true;
-          } else {
-            hasClickhouse = false;
-          }
-        } else {
-          hasClickhouse = false;
-        }
-        Config.throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhouse);
+        Config.throwIfIncompatible(changedPaths, resetCommand);
         persistence.storageStatus = {
           TAG: "Ready",
           _0: initialState$1

package/src/SimulateItems.res

@@ -320,21 +320,34 @@ let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
       let chainIdStr = chain->ChainMap.Chain.toChainId->Int.toString
       switch chainsDict->Dict.get(chainIdStr) {
       | Some(processChainJson) =>
-        let simulateRaw: option<array<JSON.t>> =
-          (processChainJson->(Utils.magic: JSON.t => {..}))["simulate"]->Nullable.toOption
+        let raw = processChainJson->(Utils.magic: JSON.t => {..})
+        let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
           let items = parse(~simulateItems, ~config, ~chainConfig)
-          // Use endBlock from processConfig (the user-specified range)
-          let startBlock: int =
-            (processChainJson->(Utils.magic: JSON.t => {..}))["startBlock"]->(
-              Utils.magic: 'a => int
-            )
-          let endBlock: int =
-            (processChainJson->(Utils.magic: JSON.t => {..}))["endBlock"]->(Utils.magic: 'a => int)
+          let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
+          let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
           let source = SimulateSource.make(~items, ~endBlock, ~chain)
           {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
-        | None => chainConfig
+        | None =>
+          // No simulate items: still honor `startBlock` / `endBlock` overrides
+          // so non-EVM/Fuel ecosystems (notably SVM `indexer.onInstruction`,
+          // which doesn't support simulate items) can bound the run window
+          // via `testIndexer.process({chains: { id: {startBlock, endBlock} }})`.
+          let startBlockOpt: option<int> =
+            raw["startBlock"]
+            ->(Utils.magic: 'a => Nullable.t<int>)
+            ->Nullable.toOption
+          let endBlockOpt: option<int> =
+            raw["endBlock"]->(Utils.magic: 'a => Nullable.t<int>)->Nullable.toOption
+          let withStart = switch startBlockOpt {
+          | Some(sb) => {...chainConfig, startBlock: sb}
+          | None => chainConfig
+          }
+          switch endBlockOpt {
+          | Some(eb) => {...withStart, endBlock: eb}
+          | None => withStart
+          }
         }
       | None => chainConfig
       }

package/src/SimulateItems.res.mjs

@@ -266,20 +266,35 @@ function patchConfig(config, processConfig) {
     }
     let simulateRaw = processChainJson.simulate;
     if (simulateRaw == null) {
-      return chainConfig;
+      let startBlockOpt = processChainJson.startBlock;
+      let endBlockOpt = processChainJson.endBlock;
+      let withStart;
+      if (startBlockOpt == null) {
+        withStart = chainConfig;
+      } else {
+        let newrecord = {...chainConfig};
+        newrecord.startBlock = startBlockOpt;
+        withStart = newrecord;
+      }
+      if (endBlockOpt == null) {
+        return withStart;
+      }
+      let newrecord$1 = {...withStart};
+      newrecord$1.endBlock = endBlockOpt;
+      return newrecord$1;
     }
     let items = parse(simulateRaw, config, chainConfig);
     let startBlock = processChainJson.startBlock;
     let endBlock = processChainJson.endBlock;
     let source = SimulateSource.make(items, endBlock, chain);
-    let newrecord = {...chainConfig};
-    newrecord.sourceConfig = {
+    let newrecord$2 = {...chainConfig};
+    newrecord$2.sourceConfig = {
       TAG: "CustomSources",
       _0: [source]
     };
-    newrecord.endBlock = endBlock;
-    newrecord.startBlock = startBlock;
-    return newrecord;
+    newrecord$2.endBlock = endBlock;
+    newrecord$2.startBlock = startBlock;
+    return newrecord$2;
   });
   let newrecord = {...config};
   newrecord.chainMap = newChainMap;

package/src/SvmTypes.res

@@ -0,0 +1,9 @@
+module Pubkey = {
+  type t
+  let schema =
+    S.string->S.setName("SVM.Pubkey")->(Utils.magic: S.t<string> => S.t<t>)
+  external fromStringUnsafe: string => t = "%identity"
+  external fromStringsUnsafe: array<string> => array<t> = "%identity"
+  external toString: t => string = "%identity"
+  external toStrings: array<t> => array<string> = "%identity"
+}