envio 3.0.2-svm-alpha.0 → 3.0.2

package/src/Persistence.res.mjs

@@ -27,7 +27,7 @@ function make(userEntities, allEnums, storage) {
   };
 }
 
-async function init(persistence, chainConfigs, envioInfo, resetCommand, resetOpt) {
+async function init(persistence, chainConfigs, envioInfo, resetCommand, runCommand, resetOpt) {
   let reset = resetOpt !== undefined ? resetOpt : false;
   try {
     let promise = persistence.storageStatus;
@@ -70,7 +70,19 @@ async function init(persistence, chainConfigs, envioInfo, resetCommand, resetOpt
         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"];
-        Config.throwIfIncompatible(changedPaths, resetCommand);
+        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);
         persistence.storageStatus = {
           TAG: "Ready",
           _0: initialState$1

package/src/SimulateItems.res

@@ -320,34 +320,21 @@ 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 raw = processChainJson->(Utils.magic: JSON.t => {..})
-        let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
+        let simulateRaw: option<array<JSON.t>> =
+          (processChainJson->(Utils.magic: JSON.t => {..}))["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
           let items = parse(~simulateItems, ~config, ~chainConfig)
-          let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
-          let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
+          // 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 source = SimulateSource.make(~items, ~endBlock, ~chain)
           {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
-        | 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
         }
       | None => chainConfig
       }

package/src/SimulateItems.res.mjs

@@ -266,35 +266,20 @@ function patchConfig(config, processConfig) {
     }
     let simulateRaw = processChainJson.simulate;
     if (simulateRaw == null) {
-      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;
+      return chainConfig;
     }
     let items = parse(simulateRaw, config, chainConfig);
     let startBlock = processChainJson.startBlock;
     let endBlock = processChainJson.endBlock;
     let source = SimulateSource.make(items, endBlock, chain);
-    let newrecord$2 = {...chainConfig};
-    newrecord$2.sourceConfig = {
+    let newrecord = {...chainConfig};
+    newrecord.sourceConfig = {
       TAG: "CustomSources",
       _0: [source]
     };
-    newrecord$2.endBlock = endBlock;
-    newrecord$2.startBlock = startBlock;
-    return newrecord$2;
+    newrecord.endBlock = endBlock;
+    newrecord.startBlock = startBlock;
+    return newrecord;
   });
   let newrecord = {...config};
   newrecord.chainMap = newChainMap;

package/src/bindings/ClickHouse.res

@@ -426,6 +426,10 @@ let initialize = async (
     | Some(engine) => ` ENGINE = ${engine}`
     | None => ""
     }
+    // Replicated database engine requires CREATE DATABASE to run on every
+    // replica; ON CLUSTER fans the DDL out via Keeper. The '{cluster}' macro
+    // resolves to each node's configured cluster name.
+    let onClusterClause = replicated ? ` ON CLUSTER '{cluster}'` : ""
 
     switch databaseEngine {
     | Some(engineSpec) => {
@@ -445,9 +449,9 @@ let initialize = async (
     | None => ()
     }
 
-    await client->exec({query: `TRUNCATE DATABASE IF EXISTS ${database}`})
+    await client->exec({query: `TRUNCATE DATABASE IF EXISTS ${database}${onClusterClause}`})
     await client->exec({
-      query: `CREATE DATABASE IF NOT EXISTS ${database}${databaseEngineClause}`,
+      query: `CREATE DATABASE IF NOT EXISTS ${database}${onClusterClause}${databaseEngineClause}`,
     })
     await client->exec({query: `USE ${database}`})
 

package/src/bindings/ClickHouse.res.mjs

@@ -301,6 +301,7 @@ async function initialize(client, database, entities, param) {
     let replicated = Env.ClickHouse.replicated();
     let databaseEngine = Env.ClickHouse.databaseEngine();
     let databaseEngineClause = databaseEngine !== undefined ? ` ENGINE = ` + databaseEngine : "";
+    let onClusterClause = replicated ? ` ON CLUSTER '{cluster}'` : "";
     if (databaseEngine !== undefined) {
       let expectedEngineName = databaseEngine.split("(")[0].trim();
       let existingResult = await client.query({
@@ -316,10 +317,10 @@ async function initialize(client, database, entities, param) {
       }
     }
     await client.exec({
-      query: `TRUNCATE DATABASE IF EXISTS ` + database
+      query: `TRUNCATE DATABASE IF EXISTS ` + database + onClusterClause
     });
     await client.exec({
-      query: `CREATE DATABASE IF NOT EXISTS ` + database + databaseEngineClause
+      query: `CREATE DATABASE IF NOT EXISTS ` + database + onClusterClause + databaseEngineClause
     });
     await client.exec({
       query: `USE ` + database

package/src/sources/EventRouter.res

@@ -116,68 +116,3 @@ 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,47 +111,6 @@ 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,
@@ -161,7 +120,5 @@ export {
   get$1 as get,
   getEvmEventId,
   fromEvmEventModsOrThrow,
-  getSvmEventId,
-  fromSvmEventConfigsOrThrow,
 }
 /* ChainMap Not a pure module */

package/src/sources/HyperSyncClient.res

@@ -155,18 +155,41 @@ 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>,
-    @as("to") to_?: 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. */
     sighash?: array<string>,
+    /** If tx.status matches this it will be returned. */
     status?: int,
-    @as("type") type_?: array<int>,
+    /** If transaction.type matches any of these values, the transaction will be returned */
+    @as("type")
+    type_?: array<int>,
     contractAddress?: array<Address.t>,
   }
 
@@ -176,30 +199,94 @@ 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,
-    @as("toBlock") toBlockExclusive?: 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.
+     */
     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,
   }
 }
@@ -298,7 +385,8 @@ module ResponseTypes = {
     gasUsed?: bigint,
     contractAddress?: string,
     logsBloom?: string,
-    @as("type") type_?: int,
+    @as("type")
+    type_?: int,
     root?: string,
     status?: int,
     l1Fee?: bigint,
@@ -328,18 +416,40 @@ 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>,
   }
 }
@@ -361,16 +471,40 @@ 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>,
 }
 
-@send
-external classNewWithAgent: (Core.hypersyncClientCtor, cfg, string) => t = "newWithAgent"
-
-let makeWithAgent = (cfg, ~userAgent) =>
-  Core.getAddon().hypersyncClient->classNewWithAgent(cfg, userAgent)
+@module("@envio-dev/hypersync-client") @scope("HypersyncClient")
+external makeWithAgent: (cfg, ~userAgent: string) => t = "newWithAgent"
 
 let make = (
   ~url,
@@ -406,19 +540,11 @@ 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.
+ * Set the log level for the underlying Rust logger in hypersync-client.
  * Must be called before creating any HypersyncClient.
  */
-let setLogLevel = (level: logLevel) => {
-  let s = switch level {
-  | #trace => "trace"
-  | #debug => "debug"
-  | #info => "info"
-  | #warn => "warn"
-  | #error => "error"
-  }
-  Core.getAddon().setLogLevel(s)
-}
+@module("@envio-dev/hypersync-client")
+external setLogLevel: logLevel => unit = "setLogLevel"
 
 module Decoder = {
   type rec decodedSolType<'a> = {val: 'a}
@@ -453,17 +579,18 @@ 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>>,
   }
 
-  @send
-  external classFromSignatures: (
-    Core.decoderCtor,
-    array<string>,
-    ~checksumAddresses: bool=?,
-  ) => t = "fromSignatures"
-
-  let fromSignatures = (signatures, ~checksumAddresses=?) =>
-    Core.getAddon().decoder->classFromSignatures(signatures, ~checksumAddresses?)
+  @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
 }

package/src/sources/HyperSyncClient.res.mjs

@@ -1,11 +1,10 @@
 // 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",
@@ -59,14 +58,12 @@ let ResponseTypes = {
   authorizationListSchema: authorizationListSchema
 };
 
-function makeWithAgent(cfg, userAgent) {
-  return Core.getAddon().HypersyncClient.newWithAgent(cfg, userAgent);
-}
+let HeightStream = {};
 
 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 makeWithAgent({
+  return HypersyncClient.HypersyncClient.newWithAgent({
     url: url,
     apiToken: apiToken,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
@@ -88,16 +85,6 @@ 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;
@@ -118,8 +105,8 @@ function toUnderlying(_d) {
   };
 }
 
-function fromSignatures(signatures, checksumAddresses) {
-  return Core.getAddon().Decoder.fromSignatures(signatures, checksumAddresses !== undefined ? Primitive_option.valFromOption(checksumAddresses) : undefined);
+function fromSignatures(prim) {
+  return HypersyncClient.Decoder.fromSignatures(prim);
 }
 
 let Decoder = {
@@ -131,10 +118,9 @@ export {
   serializationFormatSchema,
   QueryTypes,
   ResponseTypes,
-  makeWithAgent,
+  HeightStream,
   make,
   logLevelSchema,
-  setLogLevel,
   Decoder,
 }
 /* serializationFormatSchema Not a pure module */

package/src/sources/HyperSyncSource.res

@@ -192,15 +192,18 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     switch hscDecoder.contents {
     | Some(decoder) => decoder
     | None =>
-      switch HyperSyncClient.Decoder.fromSignatures(
-        allEventSignatures,
-        ~checksumAddresses=!lowercaseAddresses,
-      ) {
+      switch HyperSyncClient.Decoder.fromSignatures(allEventSignatures) {
       | exception exn =>
         exn->ErrorHandling.mkLogAndRaise(
           ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI",
         )
-      | decoder => decoder
+      | decoder =>
+        if lowercaseAddresses {
+          decoder.disableChecksummedAddresses()
+        } else {
+          decoder.enableChecksummedAddresses()
+        }
+        decoder
       }
     }
   }