envio 3.13.0-alpha.0 → 3.13.0

package/src/sources/BlockStore.res

@@ -12,16 +12,15 @@
 // blocks still inside the reorg threshold.
 type t
 
-@send external newEvm: (Core.blockStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newEvm: Core.blockStoreCtor => t = "newEvm"
 @send external newSvm: Core.blockStoreCtor => t = "newSvm"
 @send external newFuel: Core.blockStoreCtor => t = "newFuel"
 
-// The store's ecosystem is fixed here, from the chain's config. EVM carries the
-// chain's address-checksumming setting; SVM/Fuel need no extra data.
-let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+// The store's ecosystem is fixed here, from the chain's config.
+let make = (~ecosystem: Ecosystem.name): t => {
   let ctor = Core.getAddon().blockStore
   switch ecosystem {
-  | Evm => ctor->newEvm(~shouldChecksum)
+  | Evm => ctor->newEvm
   | Svm => ctor->newSvm
   | Fuel => ctor->newFuel
   }
@@ -41,7 +40,7 @@ type svmBlockInput = {slot: int, hash?: string, time?: int}
 type fuelBlockInput = {height: int, id?: string, time?: int}
 
 @send
-external fromJsEvm: (Core.blockStoreCtor, array<evmBlockInput>, bool) => t = "fromJsEvm"
+external fromJsEvm: (Core.blockStoreCtor, array<evmBlockInput>) => t = "fromJsEvm"
 @send
 external fromJsSvm: (Core.blockStoreCtor, array<svmBlockInput>) => t = "fromJsSvm"
 @send
@@ -53,7 +52,7 @@ type inputBlock = {blockNumber: int, blockHash?: string, blockTimestamp?: int}
 
 // Build a page from JS-observed blocks (RPC responses, stored reorg
 // checkpoints) for merging into the per-chain store.
-let fromJs = (blocks: array<inputBlock>, ~ecosystem: Ecosystem.name, ~shouldChecksum): t => {
+let fromJs = (blocks: array<inputBlock>, ~ecosystem: Ecosystem.name): t => {
   let ctor = Core.getAddon().blockStore
   switch ecosystem {
   | Evm =>
@@ -63,7 +62,6 @@ let fromJs = (blocks: array<inputBlock>, ~ecosystem: Ecosystem.name, ~shouldChec
         hash: ?b.blockHash,
         timestamp: ?b.blockTimestamp,
       }),
-      shouldChecksum,
     )
   | Svm =>
     ctor->fromJsSvm(
@@ -122,12 +120,15 @@ external latestValidBlockFromStore: (t, t, array<int>) => Null.t<int> = "latestV
 
 // Bulk-materialise blocks off the JS thread, one row per `blockNumbers[i]` key,
 // decoding only the fields set in that row's own `masks[i]`. Result is aligned
-// with the input.
+// with the input. `shouldChecksum` is the caller's spelling for the addresses
+// decoded out of the store: the rows themselves are raw bytes, so a page merged
+// from a differently configured store can't fix it in.
 @send
 external materialize: (
   t,
   ~blockNumbers: array<int>,
   ~masks: array<float>,
+  ~shouldChecksum: bool,
 ) => promise<array<Internal.eventBlock>> = "materialize"
 
 // Drop blocks at or below the given block (already processed), keeping the

package/src/sources/BlockStore.res.mjs

@@ -3,11 +3,11 @@
 import * as Core from "../Core.res.mjs";
 import * as FieldMask from "./FieldMask.res.mjs";
 
-function make(ecosystem, shouldChecksum) {
+function make(ecosystem) {
   let ctor = Core.getAddon().BlockStore;
   switch (ecosystem) {
     case "evm" :
-      return ctor.newEvm(shouldChecksum);
+      return ctor.newEvm();
     case "fuel" :
       return ctor.newFuel();
     case "svm" :
@@ -15,7 +15,7 @@ function make(ecosystem, shouldChecksum) {
   }
 }
 
-function fromJs(blocks, ecosystem, shouldChecksum) {
+function fromJs(blocks, ecosystem) {
   let ctor = Core.getAddon().BlockStore;
   switch (ecosystem) {
     case "evm" :
@@ -23,7 +23,7 @@ function fromJs(blocks, ecosystem, shouldChecksum) {
         number: b.blockNumber,
         hash: b.blockHash,
         timestamp: b.blockTimestamp
-      })), shouldChecksum);
+      })));
     case "fuel" :
       return ctor.fromJsFuel(blocks.map(b => ({
         height: b.blockNumber,

package/src/sources/ChainSources.res

@@ -6,6 +6,8 @@ let make = (
   ~onEventRegistrations: array<Internal.onEventRegistration>,
   ~addressStore: AddressStore.t,
   ~lowercaseAddresses: bool,
+  ~blockStore: BlockStore.t,
+  ~transactionStore: TransactionStore.t,
 ): array<Source.t> => {
   let chainId = chainConfig.id
   switch chainConfig.sourceConfig {
@@ -31,6 +33,8 @@ let make = (
       ~rpcs=evmRpcs,
       ~lowercaseAddresses,
       ~addressStore,
+      ~blockStore,
+      ~transactionStore,
     )
   | Config.FuelSourceConfig({hypersync}) => [
       FuelHyperSyncSource.make({

package/src/sources/ChainSources.res.mjs

@@ -7,7 +7,7 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as SvmHyperSyncSource from "./SvmHyperSyncSource.res.mjs";
 import * as FuelHyperSyncSource from "./FuelHyperSyncSource.res.mjs";
 
-function make(chainConfig, onEventRegistrations, addressStore, lowercaseAddresses) {
+function make(chainConfig, onEventRegistrations, addressStore, lowercaseAddresses, blockStore, transactionStore) {
   let chainId = chainConfig.id;
   let sources = chainConfig.sourceConfig;
   switch (sources.TAG) {
@@ -24,7 +24,7 @@ function make(chainConfig, onEventRegistrations, addressStore, lowercaseAddresse
           headers: headers
         };
       });
-      return EvmChain.makeSources(chainId, onEventRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore);
+      return EvmChain.makeSources(chainId, onEventRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore, blockStore, transactionStore);
     case "FuelSourceConfig" :
       return [FuelHyperSyncSource.make({
           chainId: chainId,

package/src/sources/EvmChain.res

@@ -46,6 +46,8 @@ let makeSources = (
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
   ~addressStore,
+  ~blockStore,
+  ~transactionStore,
 ) => {
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
@@ -73,6 +75,8 @@ let makeSources = (
       onEventRegistrations,
       lowercaseAddresses,
       addressStore,
+      blockStore,
+      transactionStore,
       ?ws,
       ?headers,
     })

package/src/sources/EvmChain.res.mjs

@@ -19,7 +19,7 @@ function getSyncConfig(param) {
   };
 }
 
-function makeSources(chainId, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore) {
+function makeSources(chainId, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore, blockStore, transactionStore) {
   let sources = hyperSync !== undefined ? [EvmHyperSyncSource.make({
         chainId: chainId,
         endpointUrl: hyperSync,
@@ -41,6 +41,8 @@ function makeSources(chainId, onEventRegistrations, hyperSync, rpcs, lowercaseAd
       onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
       addressStore: addressStore,
+      blockStore: blockStore,
+      transactionStore: transactionStore,
       ws: param.ws,
       headers: param.headers
     });

package/src/sources/EvmEventItem.res

@@ -0,0 +1,56 @@
+// A decoded EVM log that routed to a registration, as both EVM sources return
+// it. Everything else the log carried — its topics, its transaction hash, its
+// block hash — is consumed on the Rust side, so what crosses the boundary is
+// what an item is actually built from.
+type t = {
+  logIndex: int,
+  srcAddress: Address.t,
+  // Number of the block this log belongs to; the block itself is resolved from
+  // the chain's block store, deduplicated across items sharing a block.
+  blockNumber: int,
+  // Key (with the block number) into the transaction store; the transaction
+  // is resolved from the store on demand.
+  transactionIndex: int,
+  // The registration this log routed to, by chain-scoped index. Logs that
+  // route to no registration never cross the boundary.
+  onEventRegistrationIndex: int,
+  params: Internal.eventParams,
+}
+
+// `block` and `transaction` are omitted from the payload: both sources leave
+// them to be materialised from the per-chain stores at batch prep.
+let toInternalItem = (
+  item: t,
+  ~onEventRegistration: Internal.evmOnEventRegistration,
+  ~chainId,
+): Internal.item => {
+  let {transactionIndex, logIndex, srcAddress, blockNumber, params} = item
+
+  Internal.Event({
+    onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
+    chainId,
+    blockNumber,
+    logIndex,
+    transactionIndex,
+    payload: {
+      contractName: onEventRegistration.eventConfig.contractName,
+      eventName: onEventRegistration.eventConfig.name,
+      chainId,
+      params,
+      srcAddress,
+      logIndex,
+    }->Evm.fromPayload,
+  })
+}
+
+let toInternalItems = (
+  items: array<t>,
+  ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
+  ~chainId,
+): array<Internal.item> =>
+  items->Array.map(item =>
+    item->toInternalItem(
+      ~onEventRegistration=onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex),
+      ~chainId,
+    )
+  )

package/src/sources/EvmEventItem.res.mjs

@@ -0,0 +1,32 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function toInternalItem(item, onEventRegistration, chainId) {
+  let logIndex = item.logIndex;
+  return {
+    kind: 0,
+    onEventRegistration: onEventRegistration,
+    chainId: chainId,
+    blockNumber: item.blockNumber,
+    logIndex: logIndex,
+    transactionIndex: item.transactionIndex,
+    payload: {
+      contractName: onEventRegistration.eventConfig.contractName,
+      eventName: onEventRegistration.eventConfig.name,
+      params: item.params,
+      chainId: chainId,
+      srcAddress: item.srcAddress,
+      logIndex: logIndex
+    }
+  };
+}
+
+function toInternalItems(items, onEventRegistrations, chainId) {
+  return items.map(item => toInternalItem(item, onEventRegistrations[item.onEventRegistrationIndex], chainId));
+}
+
+export {
+  toInternalItem,
+  toInternalItems,
+}
+/* No side effect */

package/src/sources/EvmHyperSyncSource.res

@@ -55,31 +55,6 @@ let make = (
     )
   }
 
-  let makeEventBatchQueueItem = (
-    item: HyperSyncClient.EventItems.item,
-    ~onEventRegistration: Internal.evmOnEventRegistration,
-  ): Internal.item => {
-    let {transactionIndex, logIndex, srcAddress} = item
-
-    Internal.Event({
-      onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
-      chainId,
-      blockNumber: item.blockNumber,
-      logIndex,
-      transactionIndex,
-      // `block` and `transaction` are omitted; they're materialised from the
-      // per-chain stores onto the payload at batch prep.
-      payload: {
-        contractName: onEventRegistration.eventConfig.contractName,
-        eventName: onEventRegistration.eventConfig.name,
-        chainId,
-        params: item.params,
-        srcAddress,
-        logIndex,
-      }->Evm.fromPayload,
-    })
-  }
-
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
@@ -96,6 +71,8 @@ let make = (
 
     let startFetchingBatchTimeRef = Performance.now()
 
+    let fetchStats = () => RequestStat.single(~method="getLogs", ~sentAt=startFetchingBatchTimeRef)
+
     //fetch batch
     let pageUnsafe = try await HyperSync.GetLogs.query(
       ~client,
@@ -108,12 +85,12 @@ let make = (
       ~includeAllBlocks,
     ) catch {
     | HyperSync.GetLogs.Error(WrongInstance) =>
-      throw(Source.SourceBehindHead({blockNumber: fromBlock, requestStats: []}))
+      throw(Source.SourceBehindHead({blockNumber: fromBlock, requestStats: fetchStats()}))
     | HyperSync.GetLogs.Error(UnexpectedMissingParams({missingParams})) =>
       throw(
         Source.GetItemsError(
           Source.FailedGettingItems({
-            exn: %raw(`null`),
+            requestStats: fetchStats(),
             attemptedToBlock: toBlock->Option.getOr(knownHeight),
             retry: ImpossibleForTheQuery({
               message: `Source returned invalid data with missing required fields: ${missingParams->Array.joinUnsafe(
@@ -128,6 +105,7 @@ let make = (
       throw(
         Source.GetItemsError(
           Source.FailedGettingItems({
+            requestStats: fetchStats(),
             exn,
             attemptedToBlock: toBlock->Option.getOr(knownHeight),
             retry: WithBackoff({
@@ -157,15 +135,8 @@ let make = (
 
     let parsingTimeRef = Performance.now()
 
-    //Parse page items into queue items
-    let parsedQueueItems = []
-
-    pageUnsafe.items->Array.forEach(item => {
-      let onEventRegistration = onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex)
-      parsedQueueItems
-      ->Array.push(makeEventBatchQueueItem(item, ~onEventRegistration))
-      ->ignore
-    })
+    let parsedQueueItems =
+      pageUnsafe.items->EvmEventItem.toInternalItems(~onEventRegistrations, ~chainId)
 
     let parsingTimeElapsed = parsingTimeRef->Performance.secondsSince
 
@@ -186,7 +157,6 @@ let make = (
       latestFetchedBlockNumber: heighestBlockQueried,
       stats,
       knownHeight,
-      fromBlockQueried: fromBlock,
       requestStats,
     }
   }

package/src/sources/EvmHyperSyncSource.res.mjs

@@ -3,6 +3,8 @@
 import * as Source from "./Source.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
+import * as RequestStat from "./RequestStat.res.mjs";
+import * as EvmEventItem from "./EvmEventItem.res.mjs";
 import * as HyperSyncSSE from "./HyperSyncSSE.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -25,25 +27,6 @@ function make(param) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     client = ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate the hypersync client, please double check your ABI", exn);
   }
-  let makeEventBatchQueueItem = (item, onEventRegistration) => {
-    let logIndex = item.logIndex;
-    return {
-      kind: 0,
-      onEventRegistration: onEventRegistration,
-      chainId: chainId,
-      blockNumber: item.blockNumber,
-      logIndex: logIndex,
-      transactionIndex: item.transactionIndex,
-      payload: {
-        contractName: onEventRegistration.eventConfig.contractName,
-        eventName: onEventRegistration.eventConfig.name,
-        params: item.params,
-        chainId: chainId,
-        srcAddress: item.srcAddress,
-        logIndex: logIndex
-      }
-    };
-  };
   let getItemsOrThrow = async (fromBlock, toBlock, addressSet, includeAllBlocks, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let startFetchingBatchTimeRef = Performance.now();
@@ -58,7 +41,7 @@ function make(param) {
           throw {
             RE_EXN_ID: Source.SourceBehindHead,
             blockNumber: fromBlock,
-            requestStats: [],
+            requestStats: RequestStat.single("getLogs", startFetchingBatchTimeRef),
             Error: new Error()
           };
         }
@@ -66,12 +49,12 @@ function make(param) {
           RE_EXN_ID: Source.GetItemsError,
           _1: {
             TAG: "FailedGettingItems",
-            exn: null,
             attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
             retry: {
               TAG: "ImpossibleForTheQuery",
               message: `Source returned invalid data with missing required fields: ` + match.missingParams.join(", ")
-            }
+            },
+            requestStats: RequestStat.single("getLogs", startFetchingBatchTimeRef)
           },
           Error: new Error()
         };
@@ -92,7 +75,8 @@ function make(param) {
             TAG: "WithBackoff",
             message: `Unexpected issue while fetching events from HyperSync client. Attempt a retry.`,
             backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
-          }
+          },
+          requestStats: RequestStat.single("getLogs", startFetchingBatchTimeRef)
         },
         Error: new Error()
       };
@@ -106,11 +90,7 @@ function make(param) {
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     let parsingTimeRef = Performance.now();
-    let parsedQueueItems = [];
-    pageUnsafe.items.forEach(item => {
-      let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
-      parsedQueueItems.push(makeEventBatchQueueItem(item, onEventRegistration));
-    });
+    let parsedQueueItems = EvmEventItem.toInternalItems(pageUnsafe.items, onEventRegistrations, chainId);
     let parsingTimeElapsed = Performance.secondsSince(parsingTimeRef);
     let totalTimeElapsed = Performance.secondsSince(totalTimeRef);
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
@@ -125,7 +105,6 @@ function make(param) {
       parsedQueueItems: parsedQueueItems,
       transactionStore: Primitive_option.some(pageUnsafe.transactionStore),
       blockStore: pageUnsafe.blockStore,
-      fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: heighestBlockQueried,
       stats: stats,
       requestStats: requestStats

package/src/sources/EvmRpcClient.res

@@ -1,6 +1,6 @@
 type cfg = {
   url: string,
-  httpReqTimeoutMillis?: int,
+  maxConcurrentRequests?: int,
   headers?: dict<string>,
   initialBlockInterval: int,
   backoffMultiplicative: float,
@@ -10,38 +10,55 @@ type cfg = {
   queryTimeoutMillis: int,
 }
 
-// Only logs that resolved to a registration cross the boundary, each carrying
-// its registration's chain-scoped index.
-type rpcEventItem = {
-  log: Rpc.GetLogs.log,
-  onEventRegistrationIndex: int,
-  params: Internal.eventParams,
-}
-
 type nextPageParams = {
   fromBlock: int,
   toBlockCeiling: int,
   partitionId: string,
-  // The partition's registration selection, by chain-scoped index. Log
-  // selections and the routing index are derived on the Rust side from the
-  // registrations passed at construction.
   registrationIndexes: array<int>,
-  // Contract names to fetch address-free even though their registrations
-  // depend on addresses (client-side filtering). None/empty means
-  // every address-dependent contract is filtered server-side.
   clientFilteredContracts: option<array<string>>,
+  retry: int,
 }
 
-type nextPageResponse = {
-  items: array<rpcEventItem>,
+// Rust reports what to do about a page it could not read rather than throwing
+// it; see `NextPageResult` in `evm_rpc_source/mod.rs` for which fields each
+// `kind` populates. A thrown error from `getNextPage` is a genuine bug, not an
+// outcome to recover from.
+type pageOutcome =
+  | @as("Ok") Ok
+  | @as("SuggestedToBlock") SuggestedToBlock
+  | @as("Backoff") Backoff
+  | @as("FieldSelection") FieldSelection
+
+type nextPageResult = {
+  kind: pageOutcome,
+  requestStats: array<Source.requestStat>,
   toBlock: int,
+  items: array<EvmEventItem.t>,
+  message: option<string>,
+  providerMessage: option<string>,
+  blockNumber: option<int>,
+  retryToBlock: option<int>,
+  backoffMillis: option<int>,
+}
+
+// `message` is set when the read failed, in which case the page returned
+// alongside it is empty.
+type blockHashResult = {
+  message: option<string>,
   requestStats: array<Source.requestStat>,
 }
 
-// The caller provides a range; Rust decides the actual `toBlock` and returns it.
 type t = {
-  getHeight: unit => promise<int>,
-  getNextPage: (nextPageParams, AddressSet.t) => promise<nextPageResponse>,
+  getHeight: unit => promise<(int, array<Source.requestStat>)>,
+  // The stores it returns are this page's own, for the caller to merge.
+  getNextPage: (
+    nextPageParams,
+    AddressSet.t,
+    BlockStore.t,
+    TransactionStore.t,
+  ) => promise<(nextPageResult, BlockStore.t, TransactionStore.t)>,
+  getBlockHashes: array<int> => promise<(blockHashResult, BlockStore.t)>,
+  onReorg: unit => unit,
 }
 
 @send
@@ -53,48 +70,19 @@ external classNew: (
   ~addressStore: AddressStore.t,
 ) => t = "new"
 
-// Rust encodes JSON-RPC errors as a JSON payload in the napi error's
-// message: `{"kind":"JsonRpcError","code":-32005,"message":"..."}`.
-// Parse it back so callers keep matching on Rpc.JsonRpcError.
-let getJsonRpcError = (exn: exn): option<Rpc.rpcError> =>
-  switch exn {
-  | JsExn(e) =>
-    switch e->JsExn.message {
-    | Some(msg) =>
-      switch msg->JSON.parseOrThrow->JSON.Decode.object {
-      | exception _ => None
-      | None => None
-      | Some(obj) =>
-        switch (obj->Dict.get("kind"), obj->Dict.get("code"), obj->Dict.get("message")) {
-        | (Some(String("JsonRpcError")), Some(Number(code)), Some(String(message))) =>
-          Some({code: code->Float.toInt, message})
-        | _ => None
-        }
-      }
-    | None => None
-    }
-  | _ => None
-  }
-
-let coerceErrorOrThrow = exn =>
-  switch exn->getJsonRpcError {
-  | Some(rpcError) => throw(Rpc.JsonRpcError(rpcError))
-  | None => exn->throw
-  }
-
 let make = (
   ~url,
   ~checksumAddresses,
   ~syncConfig: Config.sourceSync,
-  ~httpReqTimeoutMillis=?,
+  ~maxConcurrentRequests=?,
   ~headers=?,
   ~eventRegistrations=[],
   ~addressStore,
-) => {
-  let client = Core.getAddon().evmRpcClient->classNew(
+) =>
+  Core.getAddon().evmRpcClient->classNew(
     {
       url,
-      ?httpReqTimeoutMillis,
+      ?maxConcurrentRequests,
       ?headers,
       initialBlockInterval: syncConfig.initialBlockInterval,
       backoffMultiplicative: syncConfig.backoffMultiplicative,
@@ -107,9 +95,3 @@ let make = (
     ~checksumAddresses,
     ~addressStore,
   )
-  {
-    getHeight: () => client.getHeight()->Promise.catch(coerceErrorOrThrow),
-    getNextPage: (params, addressSet) =>
-      client.getNextPage(params, addressSet)->Promise.catch(coerceErrorOrThrow),
-  }
-}

package/src/sources/EvmRpcClient.res.mjs

@@ -1,56 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Rpc from "./Rpc.res.mjs";
 import * as Core from "../Core.res.mjs";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
-import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 
-function getJsonRpcError(exn) {
-  if (exn.RE_EXN_ID !== "JsExn") {
-    return;
-  }
-  let msg = Stdlib_JsExn.message(exn._1);
-  if (msg === undefined) {
-    return;
-  }
-  let obj;
-  try {
-    obj = Stdlib_JSON.Decode.object(JSON.parse(msg));
-  } catch (exn$1) {
-    return;
-  }
-  if (obj === undefined) {
-    return;
-  }
-  let match = obj["kind"];
-  let match$1 = obj["code"];
-  let match$2 = obj["message"];
-  if (match === "JsonRpcError" && typeof match$1 === "number" && typeof match$2 === "string") {
-    return {
-      code: match$1 | 0,
-      message: match$2
-    };
-  }
-}
-
-function coerceErrorOrThrow(exn) {
-  let rpcError = getJsonRpcError(exn);
-  if (rpcError !== undefined) {
-    throw {
-      RE_EXN_ID: Rpc.JsonRpcError,
-      _1: rpcError,
-      Error: new Error()
-    };
-  }
-  throw exn;
-}
-
-function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt, addressStore) {
+function make(url, checksumAddresses, syncConfig, maxConcurrentRequests, headers, eventRegistrationsOpt, addressStore) {
   let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
-  let client = Core.getAddon().EvmRpcClient.new({
+  return Core.getAddon().EvmRpcClient.new({
     url: url,
-    httpReqTimeoutMillis: httpReqTimeoutMillis,
+    maxConcurrentRequests: maxConcurrentRequests,
     headers: headers,
     initialBlockInterval: syncConfig.initialBlockInterval,
     backoffMultiplicative: syncConfig.backoffMultiplicative,
@@ -59,15 +15,9 @@ function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers,
     backoffMillis: syncConfig.backoffMillis,
     queryTimeoutMillis: syncConfig.queryTimeoutMillis
   }, eventRegistrations, checksumAddresses, addressStore);
-  return {
-    getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
-    getNextPage: (params, addressSet) => Stdlib_Promise.$$catch(client.getNextPage(params, addressSet), coerceErrorOrThrow)
-  };
 }
 
 export {
-  getJsonRpcError,
-  coerceErrorOrThrow,
   make,
 }
-/* Rpc Not a pure module */
+/* Core Not a pure module */

package/src/sources/EvmRpcWs.res

@@ -43,6 +43,9 @@ let refusesSubscribe = (id, ~subscribed) =>
   | Some(id) => id === subscribeRequestIdText
   }
 
+external number: string => int = "Number"
+let hexIntSchema: S.schema<int> = S.string->S.transform(_ => {parser: str => str->number})
+
 let wsMessageSchema = S.union([
   S.object(s => {
     let _ = s.field("method", S.literal("eth_subscription"))
@@ -54,7 +57,7 @@ let wsMessageSchema = S.union([
             "result",
             S.object(
               s => {
-                s.field("number", Rpc.hexIntSchema)
+                s.field("number", hexIntSchema)
               },
             ),
           )