envio 3.0.1 → 3.0.2-svm-alpha.1

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"
+}

package/src/SvmTypes.res.mjs

@@ -0,0 +1,14 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+let schema = S$RescriptSchema.setName(S$RescriptSchema.string, "SVM.Pubkey");
+
+let Pubkey = {
+  schema: schema
+};
+
+export {
+  Pubkey,
+}
+/* schema Not a pure module */

package/src/sources/EventRouter.res

@@ -116,3 +116,68 @@ let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain):
   })
   router
 }
+
+/** Dispatch key for SVM instructions. `None` matches any instruction in the
+ program (lowest priority). */
+let getSvmEventId = (~programId: SvmTypes.Pubkey.t, ~discriminator: option<string>) =>
+  switch discriminator {
+  | None => (programId->SvmTypes.Pubkey.toString) ++ "_none"
+  | Some(d) => (programId->SvmTypes.Pubkey.toString) ++ "_" ++ d
+  }
+
+/** Discriminator byte-lengths declared by a program, sorted descending. The
+ source uses this to probe `(programId, dN)` keys longest-first when routing
+ a returned instruction to a handler — matching the locked Q1 answer. */
+type svmProgramOrdering = {
+  programId: SvmTypes.Pubkey.t,
+  /** Byte lengths in descending order, deduplicated. Includes `0` only when
+   a handler is registered with no discriminator (program-wide match). */
+  byteLengthsDesc: array<int>,
+}
+
+let fromSvmEventConfigsOrThrow = (
+  events: array<Internal.svmInstructionEventConfig>,
+  ~chain,
+): (t<Internal.svmInstructionEventConfig>, array<svmProgramOrdering>) => {
+  let router = empty()
+  events->Belt.Array.forEach(config => {
+    // The router tag must include the programId so two programs declaring the
+    // same discriminator coexist. The source-side lookup uses the same shape
+    // via `getSvmEventId(~programId, ~discriminator)`.
+    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    router->addOrThrow(
+      routerTag,
+      config,
+      ~contractName=config.contractName,
+      ~eventName=config.name,
+      ~chain,
+      ~isWildcard=config.isWildcard,
+    )
+  })
+
+  // Per-program list of declared discriminator byte lengths, sorted desc.
+  let byProgram: dict<Utils.Set.t<int>> = Dict.make()
+  events->Belt.Array.forEach(config => {
+    let key = config.programId->SvmTypes.Pubkey.toString
+    let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
+    | Some(s) => s
+    | None =>
+      let s = Utils.Set.make()
+      byProgram->Dict.set(key, s)
+      s
+    }
+    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+  })
+  let ordering =
+    byProgram
+    ->Dict.toArray
+    ->Array.map(((programIdString, lens)) => {
+      let sorted = lens->Utils.Set.toArray->Array.toSorted((a, b) => (b - a)->Int.toFloat)
+      {
+        programId: programIdString->SvmTypes.Pubkey.fromStringUnsafe,
+        byteLengthsDesc: sorted,
+      }
+    })
+
+  (router, ordering)
+}

package/src/sources/EventRouter.res.mjs

@@ -111,6 +111,47 @@ function fromEvmEventModsOrThrow(events, chain) {
   return router;
 }
 
+function getSvmEventId(programId, discriminator) {
+  if (discriminator !== undefined) {
+    return programId + "_" + discriminator;
+  } else {
+    return programId + "_none";
+  }
+}
+
+function fromSvmEventConfigsOrThrow(events, chain) {
+  let router = {};
+  Belt_Array.forEach(events, config => {
+    let routerTag = getSvmEventId(config.programId, config.discriminator);
+    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+  });
+  let byProgram = {};
+  Belt_Array.forEach(events, config => {
+    let key = config.programId;
+    let s = byProgram[key];
+    let set;
+    if (s !== undefined) {
+      set = Primitive_option.valFromOption(s);
+    } else {
+      let s$1 = new Set();
+      byProgram[key] = s$1;
+      set = s$1;
+    }
+    set.add(config.discriminatorByteLen);
+  });
+  let ordering = Object.entries(byProgram).map(param => {
+    let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);
+    return {
+      programId: param[0],
+      byteLengthsDesc: sorted
+    };
+  });
+  return [
+    router,
+    ordering
+  ];
+}
+
 export {
   EventDuplicate,
   WildcardCollision,
@@ -120,5 +161,7 @@ export {
   get$1 as get,
   getEvmEventId,
   fromEvmEventModsOrThrow,
+  getSvmEventId,
+  fromSvmEventConfigsOrThrow,
 }
 /* ChainMap Not a pure module */

package/src/sources/HyperSyncClient.res

@@ -155,41 +155,18 @@ module QueryTypes = {
   )
 
   type logFilter = {
-    /**
-     * Address of the contract, any logs that has any of these addresses will be returned.
-     * Empty means match all.
-     */
     address?: array<Address.t>,
-    /**
-     * Topics to match, each member of the top level array is another array, if the nth topic matches any
-     *  topic specified in topics[n] the log will be returned. Empty means match all.
-     */
     topics: topicSelection,
   }
 
   let makeLogSelection = (~address, ~topics) => {address, topics}
 
   type transactionFilter = {
-    /**
-     * Address the transaction should originate from. If transaction.from matches any of these, the transaction
-     *  will be returned. Keep in mind that this has an and relationship with to filter, so each transaction should
-     *  match both of them. Empty means match all.
-     */
     from?: array<Address.t>,
-    /**
-     * Address the transaction should go to. If transaction.to matches any of these, the transaction will
-     *  be returned. Keep in mind that this has an and relationship with from filter, so each transaction should
-     *  match both of them. Empty means match all.
-     */
-    @as("to")
-    to_?: array<Address.t>,
-    /** If first 4 bytes of transaction input matches any of these, transaction will be returned. Empty means match all. */
+    @as("to") to_?: array<Address.t>,
     sighash?: array<string>,
-    /** If tx.status matches this it will be returned. */
     status?: int,
-    /** If transaction.type matches any of these values, the transaction will be returned */
-    @as("type")
-    type_?: array<int>,
+    @as("type") type_?: array<int>,
     contractAddress?: array<Address.t>,
   }
 
@@ -199,94 +176,30 @@ module QueryTypes = {
     address?: array<Address.t>,
     callType?: array<string>,
     rewardType?: array<string>,
-    @as("type")
-    type_?: array<string>,
+    @as("type") type_?: array<string>,
     sighash?: array<string>,
   }
 
   type blockSelection = {
-    /**
-     * Hash of a block, any blocks that have one of these hashes will be returned.
-     * Empty means match all.
-     */
     hash?: array<string>,
-    /**
-     * Miner address of a block, any blocks that have one of these miners will be returned.
-     * Empty means match all.
-     */
     miner?: array<Address.t>,
   }
 
   type joinMode = | @as(0) Default | @as(1) JoinAll | @as(2) JoinNothing
 
   type query = {
-    /** The block to start the query from */
     fromBlock: int,
-    /**
-     * The block to end the query at. If not specified, the query will go until the
-     *  end of data. Exclusive, the returned range will be [from_block..to_block).
-     *
-     * The query will return before it reaches this target block if it hits the time limit
-     *  configured on the server. The user should continue their query by putting the
-     *  next_block field in the response into from_block field of their next query. This implements
-     *  pagination.
-     */
-    @as("toBlock")
-    toBlockExclusive?: int,
-    /**
-     * List of log selections, these have an or relationship between them, so the query will return logs
-     * that match any of these selections.
-     */
+    @as("toBlock") toBlockExclusive?: int,
     logs?: array<logFilter>,
-    /**
-     * List of transaction selections, the query will return transactions that match any of these selections and
-     *  it will return transactions that are related to the returned logs.
-     */
     transactions?: array<transactionFilter>,
-    /**
-     * List of trace selections, the query will return traces that match any of these selections and
-     *  it will re turn traces that are related to the returned logs.
-     */
     traces?: array<traceSelection>,
-    /** List of block selections, the query will return blocks that match any of these selections */
     blocks?: array<blockSelection>,
-    /**
-     * Field selection. The user can select which fields they are interested in, requesting less fields will improve
-     *  query execution time and reduce the payload size so the user should always use a minimal number of fields.
-     */
     fieldSelection: fieldSelection,
-    /**
-     * Maximum number of blocks that should be returned, the server might return more blocks than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumBlocks?: int,
-    /**
-     * Maximum number of transactions that should be returned, the server might return more transactions than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumTransactions?: int,
-    /**
-     * Maximum number of logs that should be returned, the server might return more logs than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumLogs?: int,
-    /**
-     * Maximum number of traces that should be returned, the server might return more traces than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumTraces?: int,
-    /**
-     * Selects join mode for the query,
-     * Default: join in this order logs -> transactions -> traces -> blocks
-     * JoinAll: join everything to everything. For example if logSelection matches log0, we get the
-     * associated transaction of log0 and then we get associated logs of that transaction as well. Applites similarly
-     * to blocks, traces.
-     * JoinNothing: join nothing.
-     */
     joinMode?: joinMode,
-    /**
-     * If set to true, the server will return data for all blocks in the requested range [from_block, to_block).
-     */
     includeAllBlocks?: bool,
   }
 }
@@ -385,8 +298,7 @@ module ResponseTypes = {
     gasUsed?: bigint,
     contractAddress?: string,
     logsBloom?: string,
-    @as("type")
-    type_?: int,
+    @as("type") type_?: int,
     root?: string,
     status?: int,
     l1Fee?: bigint,
@@ -416,40 +328,18 @@ module ResponseTypes = {
   }
 
   type rollbackGuard = {
-    /** Block number of the last scanned block */
     blockNumber: int,
-    /** Block timestamp of the last scanned block */
     timestamp: int,
-    /** Block hash of the last scanned block */
     hash: string,
-    /**
-   * Block number of the first scanned block in memory.
-   *
-   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
-   */
     firstBlockNumber: int,
-    /**
-   * Parent hash of the first scanned block in memory.
-   *
-   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
-   */
     firstParentHash: string,
   }
 
   type eventResponse = {
-    /** Current height of the source hypersync instance */
     archiveHeight: option<int>,
-    /**
-     * Next block to query for, the responses are paginated so,
-     *  the caller should continue the query from this block if they
-     *  didn't get responses up to the to_block they specified in the Query.
-     */
     nextBlock: int,
-    /** Total time it took the hypersync instance to execute the query. */
     totalExecutionTime: int,
-    /** Response data */
     data: array<event>,
-    /** Rollback guard, supposed to be used to detect rollbacks */
     rollbackGuard: option<rollbackGuard>,
   }
 }
@@ -471,40 +361,16 @@ type queryResponse = {
   rollbackGuard: option<ResponseTypes.rollbackGuard>,
 }
 
-//Todo, add bindings for these types
-type streamConfig
-type queryResponseStream
-type eventStream
-
-@tag("type")
-type heightStreamEvent =
-  | Height({height: int})
-  | Connected
-  | Reconnecting({delayMillis: int, errorMsg: string})
-
-module HeightStream = {
-  type t = {
-    /** Close the height stream */
-    close: unit => promise<unit>,
-    /** Receive the next height stream event from the stream */
-    recv: unit => promise<heightStreamEvent>,
-  }
-}
-
 type t = {
-  getHeight: unit => promise<int>,
-  collect: (~query: query, ~config: streamConfig) => promise<queryResponse>,
-  collectEvents: (~query: query, ~config: streamConfig) => promise<eventResponse>,
-  collectParquet: (~path: string, ~query: query, ~config: streamConfig) => promise<unit>,
   get: (~query: query) => promise<queryResponse>,
   getEvents: (~query: query) => promise<eventResponse>,
-  stream: (~query: query, ~config: streamConfig) => promise<queryResponseStream>,
-  streamEvents: (~query: query, ~config: streamConfig) => promise<eventStream>,
-  streamHeight: unit => promise<HeightStream.t>,
 }
 
-@module("@envio-dev/hypersync-client") @scope("HypersyncClient")
-external makeWithAgent: (cfg, ~userAgent: string) => t = "newWithAgent"
+@send
+external classNewWithAgent: (Core.hypersyncClientCtor, cfg, string) => t = "newWithAgent"
+
+let makeWithAgent = (cfg, ~userAgent) =>
+  Core.getAddon().hypersyncClient->classNewWithAgent(cfg, userAgent)
 
 let make = (
   ~url,
@@ -540,11 +406,19 @@ type logLevel = [#trace | #debug | #info | #warn | #error]
 let logLevelSchema: S.t<logLevel> = S.enum([#trace, #debug, #info, #warn, #error])
 
 /**
- * Set the log level for the underlying Rust logger in hypersync-client.
+ * Set the log level for the underlying Rust logger.
  * Must be called before creating any HypersyncClient.
  */
-@module("@envio-dev/hypersync-client")
-external setLogLevel: logLevel => unit = "setLogLevel"
+let setLogLevel = (level: logLevel) => {
+  let s = switch level {
+  | #trace => "trace"
+  | #debug => "debug"
+  | #info => "info"
+  | #warn => "warn"
+  | #error => "error"
+  }
+  Core.getAddon().setLogLevel(s)
+}
 
 module Decoder = {
   type rec decodedSolType<'a> = {val: 'a}
@@ -579,18 +453,17 @@ module Decoder = {
     body: array<decodedRaw>,
   }
 
-  type log
   type t = {
-    enableChecksummedAddresses: unit => unit,
-    disableChecksummedAddresses: unit => unit,
-    decodeLogs: array<log> => promise<array<Nullable.t<decodedEvent>>>,
-    decodeLogsSync: array<log> => array<Nullable.t<decodedEvent>>,
     decodeEvents: array<ResponseTypes.event> => promise<array<Nullable.t<decodedEvent>>>,
-    decodeEventsSync: array<ResponseTypes.event> => array<Nullable.t<decodedEvent>>,
   }
 
-  @module("@envio-dev/hypersync-client") @scope("Decoder")
-  external fromSignatures: array<string> => t = "fromSignatures"
-  // Keep the @envio-dev/hypersync-client import inside of the package
-  let fromSignatures = fromSignatures
+  @send
+  external classFromSignatures: (
+    Core.decoderCtor,
+    array<string>,
+    ~checksumAddresses: bool=?,
+  ) => t = "fromSignatures"
+
+  let fromSignatures = (signatures, ~checksumAddresses=?) =>
+    Core.getAddon().decoder->classFromSignatures(signatures, ~checksumAddresses?)
 }

package/src/sources/HyperSyncClient.res.mjs

@@ -1,10 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Address from "../Address.res.mjs";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as HypersyncClient from "@envio-dev/hypersync-client";
 
 let serializationFormatSchema = S$RescriptSchema.$$enum([
   "Json",
@@ -58,12 +59,14 @@ let ResponseTypes = {
   authorizationListSchema: authorizationListSchema
 };
 
-let HeightStream = {};
+function makeWithAgent(cfg, userAgent) {
+  return Core.getAddon().HypersyncClient.newWithAgent(cfg, userAgent);
+}
 
 function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs) {
   let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
   let envioVersion = Utils.EnvioPackage.value.version;
-  return HypersyncClient.HypersyncClient.newWithAgent({
+  return makeWithAgent({
     url: url,
     apiToken: apiToken,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
@@ -85,6 +88,16 @@ let logLevelSchema = S$RescriptSchema.$$enum([
   "error"
 ]);
 
+function setLogLevel(level) {
+  Core.getAddon().setLogLevel(level === "warn" ? "warn" : (
+      level === "debug" ? "debug" : (
+          level === "error" ? "error" : (
+              level === "trace" ? "trace" : "info"
+            )
+        )
+    ));
+}
+
 function toUnderlying(_d) {
   while (true) {
     let d = _d;
@@ -105,8 +118,8 @@ function toUnderlying(_d) {
   };
 }
 
-function fromSignatures(prim) {
-  return HypersyncClient.Decoder.fromSignatures(prim);
+function fromSignatures(signatures, checksumAddresses) {
+  return Core.getAddon().Decoder.fromSignatures(signatures, checksumAddresses !== undefined ? Primitive_option.valFromOption(checksumAddresses) : undefined);
 }
 
 let Decoder = {
@@ -118,9 +131,10 @@ export {
   serializationFormatSchema,
   QueryTypes,
   ResponseTypes,
-  HeightStream,
+  makeWithAgent,
   make,
   logLevelSchema,
+  setLogLevel,
   Decoder,
 }
 /* serializationFormatSchema Not a pure module */