envio 3.3.0-alpha.4 → 3.3.0-alpha.5

package/src/bindings/Viem.res

@@ -1,52 +1,11 @@
-type eventLog = {
-  abi: EvmTypes.Abi.t,
-  data: string,
-  topics: array<EvmTypes.Hex.t>,
-}
-
-type decodedEvent<'a> = {
-  eventName: string,
-  args: 'a,
-}
-
-@module("viem") external decodeEventLogOrThrow: eventLog => decodedEvent<'a> = "decodeEventLog"
-
 type hex = EvmTypes.Hex.t
 @module("viem") external toHex: 'a => hex = "toHex"
 @module("viem") external keccak256: hex => hex = "keccak256"
-@module("viem") external keccak256Bytes: Uint8Array.t => hex = "keccak256"
 @module("viem") external pad: hex => hex = "pad"
-@module("viem")
-external encodePacked: (~types: array<string>, ~values: array<'a>) => hex = "encodePacked"
 
 type sizeOptions = {size: int}
-@module("viem") external intToHex: (int, ~options: sizeOptions=?) => hex = "numberToHex"
 @module("viem") external bigintToHex: (bigint, ~options: sizeOptions=?) => hex = "numberToHex"
 @module("viem") external stringToHex: (string, ~options: sizeOptions=?) => hex = "stringToHex"
 @module("viem") external boolToHex: (bool, ~options: sizeOptions=?) => hex = "boolToHex"
 @module("viem") external bytesToHex: (Uint8Array.t, ~options: sizeOptions=?) => hex = "bytesToHex"
 @module("viem") external concat: array<hex> => hex = "concat"
-
-exception ParseError(exn)
-exception UnknownContractName({contractName: string})
-
-let parseLogOrThrow = (
-  contractNameAbiMapping: dict<EvmTypes.Abi.t>,
-  ~contractName,
-  ~topics,
-  ~data,
-) => {
-  switch contractNameAbiMapping->Utils.Dict.dangerouslyGetNonOption(contractName) {
-  | None => throw(UnknownContractName({contractName: contractName}))
-  | Some(abi) =>
-    let viemLog: eventLog = {
-      abi,
-      data,
-      topics,
-    }
-
-    try viemLog->decodeEventLogOrThrow catch {
-    | exn => throw(ParseError(exn))
-    }
-  }
-}

package/src/bindings/Viem.res.mjs

@@ -1,44 +1,2 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Viem from "viem";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-let ParseError = /* @__PURE__ */Primitive_exceptions.create("Viem.ParseError");
-
-let UnknownContractName = /* @__PURE__ */Primitive_exceptions.create("Viem.UnknownContractName");
-
-function parseLogOrThrow(contractNameAbiMapping, contractName, topics, data) {
-  let abi = contractNameAbiMapping[contractName];
-  if (abi !== undefined) {
-    let viemLog_abi = Primitive_option.valFromOption(abi);
-    let viemLog = {
-      abi: viemLog_abi,
-      data: data,
-      topics: topics
-    };
-    try {
-      return Viem.decodeEventLog(viemLog);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: ParseError,
-        _1: exn,
-        Error: new Error()
-      };
-    }
-  } else {
-    throw {
-      RE_EXN_ID: UnknownContractName,
-      contractName: contractName,
-      Error: new Error()
-    };
-  }
-}
-
-export {
-  ParseError,
-  UnknownContractName,
-  parseLogOrThrow,
-}
-/* viem Not a pure module */
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/sources/Evm.res

@@ -15,42 +15,13 @@ type payload = {
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
 
-// Ordered transaction field names. The index of each is the field code shared
-// with the Rust store (`EvmTxField`) — keep this order in sync.
-let transactionFields = [
-  "transactionIndex",
-  "hash",
-  "from",
-  "to",
-  "gas",
-  "gasPrice",
-  "maxPriorityFeePerGas",
-  "maxFeePerGas",
-  "cumulativeGasUsed",
-  "effectiveGasPrice",
-  "gasUsed",
-  "input",
-  "nonce",
-  "value",
-  "v",
-  "r",
-  "s",
-  "contractAddress",
-  "logsBloom",
-  "root",
-  "status",
-  "yParity",
-  "maxFeePerBlobGas",
-  "blobVersionedHashes",
-  "type",
-  "l1Fee",
-  "l1GasPrice",
-  "l1GasUsed",
-  "l1FeeScalar",
-  "gasUsedForL1",
-  "accessList",
-  "authorizationList",
-]
+// Ordered transaction field names, the field codes shared with the Rust store
+// (`EvmTxField`). Derived from the typed field list so the two can't drift;
+// `Internal.allEvmTransactionFields` is pinned to the Rust ordinal order by a test.
+let transactionFields =
+  Internal.allEvmTransactionFields->(
+    Utils.magic: array<Internal.evmTransactionField> => array<string>
+  )
 
 // One event's selected transaction fields → store selection bitmask. Computed
 // per event at config build and cached on the event config.

package/src/sources/Evm.res.mjs

@@ -1,46 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Logging from "../Logging.res.mjs";
+import * as Internal from "../Internal.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as TransactionStore from "./TransactionStore.res.mjs";
 
-let transactionFields = [
-  "transactionIndex",
-  "hash",
-  "from",
-  "to",
-  "gas",
-  "gasPrice",
-  "maxPriorityFeePerGas",
-  "maxFeePerGas",
-  "cumulativeGasUsed",
-  "effectiveGasPrice",
-  "gasUsed",
-  "input",
-  "nonce",
-  "value",
-  "v",
-  "r",
-  "s",
-  "contractAddress",
-  "logsBloom",
-  "root",
-  "status",
-  "yParity",
-  "maxFeePerBlobGas",
-  "blobVersionedHashes",
-  "type",
-  "l1Fee",
-  "l1GasPrice",
-  "l1GasUsed",
-  "l1FeeScalar",
-  "gasUsedForL1",
-  "accessList",
-  "authorizationList"
-];
-
-let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields);
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allEvmTransactionFields);
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
@@ -76,6 +42,8 @@ function make(logger) {
   };
 }
 
+let transactionFields = Internal.allEvmTransactionFields;
+
 export {
   transactionFields,
   eventTransactionFieldMask,

package/src/sources/EvmChain.res

@@ -3,6 +3,7 @@ type rpc = {
   sourceFor: Source.sourceFor,
   syncConfig?: Config.sourceSyncOptions,
   ws?: string,
+  headers?: dict<string>,
 }
 
 let getSyncConfig = (
@@ -89,7 +90,7 @@ let makeSources = (
     ]
   | _ => []
   }
-  rpcs->Array.forEach(({?syncConfig, url, sourceFor, ?ws}) => {
+  rpcs->Array.forEach(({?syncConfig, url, sourceFor, ?ws, ?headers}) => {
     let source = RpcSource.make({
       chain,
       sourceFor,
@@ -99,6 +100,7 @@ let makeSources = (
       allEventParams,
       lowercaseAddresses,
       ?ws,
+      ?headers,
     })
     let _ = sources->Array.push(source)
   })

package/src/sources/EvmChain.res.mjs

@@ -60,7 +60,8 @@ function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
       eventRouter: eventRouter,
       allEventParams: allEventParams,
       lowercaseAddresses: lowercaseAddresses,
-      ws: param.ws
+      ws: param.ws,
+      headers: param.headers
     });
     sources.push(source);
   });

package/src/sources/EvmRpcClient.res

@@ -1,9 +1,34 @@
-type cfg = {url: string, httpReqTimeoutMillis?: int}
+type cfg = {url: string, httpReqTimeoutMillis?: int, headers?: dict<string>}
 
-type t = {getHeight: unit => promise<int>}
+// `addresses` omitted matches any address (a wildcard selection). Each `topics`
+// position is `null` (match any) or a list of accepted topic hashes; the
+// single-match case is a one-element list.
+type getLogsParams = {
+  fromBlock: int,
+  toBlock: int,
+  addresses?: array<Address.t>,
+  topics: array<Nullable.t<array<string>>>,
+}
+
+// Decoded `params` keyed by contract name, matching the HyperSync decoder's
+// shape so the caller routes by address then picks its contract's params.
+type rpcEventItem = {
+  log: Rpc.GetLogs.log,
+  params: Nullable.t<dict<Internal.eventParams>>,
+}
+
+type t = {
+  getHeight: unit => promise<int>,
+  getLogs: getLogsParams => promise<array<rpcEventItem>>,
+}
 
 @send
-external classNew: (Core.evmRpcClientCtor, cfg) => t = "new"
+external classNew: (
+  Core.evmRpcClientCtor,
+  cfg,
+  array<HyperSyncClient.Decoder.eventParamsInput>,
+  ~checksumAddresses: bool,
+) => t = "new"
 
 // Rust encodes JSON-RPC errors as a JSON payload in the napi error's
 // message: `{"kind":"JsonRpcError","code":-32005,"message":"..."}`.
@@ -34,9 +59,15 @@ let coerceErrorOrThrow = exn =>
   | None => exn->throw
   }
 
-let make = (~url, ~httpReqTimeoutMillis=?) => {
-  let client = Core.getAddon().evmRpcClient->classNew({url, ?httpReqTimeoutMillis})
+let make = (~url, ~checksumAddresses, ~httpReqTimeoutMillis=?, ~headers=?, ~allEventParams=[]) => {
+  let client =
+    Core.getAddon().evmRpcClient->classNew(
+      {url, ?httpReqTimeoutMillis, ?headers},
+      allEventParams,
+      ~checksumAddresses,
+    )
   {
     getHeight: () => client.getHeight()->Promise.catch(coerceErrorOrThrow),
+    getLogs: params => client.getLogs(params)->Promise.catch(coerceErrorOrThrow),
   }
 }

package/src/sources/EvmRpcClient.res.mjs

@@ -46,13 +46,16 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, httpReqTimeoutMillis) {
+function make(url, checksumAddresses, httpReqTimeoutMillis, headers, allEventParamsOpt) {
+  let allEventParams = allEventParamsOpt !== undefined ? allEventParamsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
-    httpReqTimeoutMillis: httpReqTimeoutMillis
-  });
+    httpReqTimeoutMillis: httpReqTimeoutMillis,
+    headers: headers
+  }, allEventParams, checksumAddresses);
   return {
-    getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow)
+    getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
+    getLogs: params => Stdlib_Promise.$$catch(client.getLogs(params), coerceErrorOrThrow)
   };
 }
 

package/src/sources/HyperSyncClient.res

@@ -208,22 +208,6 @@ module ResponseTypes = {
     mixHash?: string,
   }
 
-  type log = {
-    removed?: bool,
-    @as("logIndex") index?: int,
-    transactionIndex?: int,
-    transactionHash?: string,
-    blockHash?: string,
-    blockNumber?: int,
-    address?: Address.t,
-    data?: string,
-    topics?: array<Nullable.t<EvmTypes.Hex.t>>,
-  }
-
-  // Only the log is needed for decoding; the transaction/block are served from
-  // the store (event items) or unused (block-hash query).
-  type event = {log: log}
-
   type rollbackGuard = {
     blockNumber: int,
     timestamp: int,
@@ -253,25 +237,6 @@ module Decoder = {
     contractName: string,
     params: array<Internal.paramMeta>,
   }
-
-  // Decoded params keyed by contract name. Contracts that emit the same-signature
-  // event share one decode but get their own param names, so the caller picks the
-  // entry for the contract its router resolved the log to.
-  type tWithParams = {
-    decodeLogs: array<ResponseTypes.event> => promise<
-      array<Nullable.t<dict<Internal.eventParams>>>,
-    >,
-  }
-
-  @send
-  external classFromParams: (
-    Core.evmDecoderCtor,
-    array<eventParamsInput>,
-    ~checksumAddresses: bool=?,
-  ) => tWithParams = "fromParams"
-
-  let fromParams = (eventParams, ~checksumAddresses=?) =>
-    Core.getAddon().evmDecoder->classFromParams(eventParams, ~checksumAddresses?)
 }
 
 module EventItems = {

package/src/sources/HyperSyncClient.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 let serializationFormatSchema = S$RescriptSchema.$$enum([
@@ -37,13 +36,7 @@ let QueryTypes = {
 
 let ResponseTypes = {};
 
-function fromParams(eventParams, checksumAddresses) {
-  return Core.getAddon().EvmDecoder.fromParams(eventParams, checksumAddresses !== undefined ? Primitive_option.valFromOption(checksumAddresses) : undefined);
-}
-
-let Decoder = {
-  fromParams: fromParams
-};
+let Decoder = {};
 
 let EventItems = {};
 

package/src/sources/Rpc.res

@@ -38,7 +38,21 @@ let jsonRpcFetcher: Rest.ApiFetcher.t = async args => {
   }
 }
 
-let makeClient = url => Rest.client(url, ~fetcher=jsonRpcFetcher)
+let makeClient = (url, ~headers=?) => {
+  let fetcher: Rest.ApiFetcher.t = switch headers {
+  | None => jsonRpcFetcher
+  | Some(customHeaders) =>
+    async args => {
+      let headers = switch args.headers {
+      | Some(headers) => headers
+      | None => Dict.make()
+      }
+      customHeaders->Dict.forEachWithKey((value, key) => headers->Dict.set(key, value->Obj.magic))
+      await jsonRpcFetcher({...args, headers: Some(headers)})
+    }
+  }
+  Rest.client(url, ~fetcher)
+}
 
 type hex = string
 let makeHexSchema = fromStr =>
@@ -70,13 +84,7 @@ let decimalFloatSchema: S.schema<float> = S.string->S.transform(s => {
 module GetLogs = {
   @unboxed
   type topicFilter = Single(hex) | Multiple(array<hex>) | @as(null) Null
-  let topicFilterSchema = S.union([
-    S.literal(Null),
-    S.schema(s => Multiple(s.matches(S.array(S.string)))),
-    S.schema(s => Single(s.matches(S.string))),
-  ])
   type topicQuery = array<topicFilter>
-  let topicQuerySchema = S.array(topicFilterSchema)
 
   let makeTopicQuery = (~topic0=[], ~topic1=[], ~topic2=[], ~topic3=[]) => {
     let topics = [topic0, topic1, topic2, topic3]
@@ -106,51 +114,15 @@ module GetLogs = {
   let mapTopicQuery = ({topic0, topic1, topic2, topic3}: Internal.topicSelection): topicQuery =>
     makeTopicQuery(~topic0, ~topic1, ~topic2, ~topic3)
 
-  type param = {
-    fromBlock: int,
-    toBlock: int,
-    address?: array<Address.t>,
-    topics: topicQuery,
-    // blockHash?: string,
-  }
-
-  let paramsSchema = S.object((s): param => {
-    fromBlock: s.field("fromBlock", hexIntSchema),
-    toBlock: s.field("toBlock", hexIntSchema),
-    address: ?s.field("address", S.option(S.array(Address.schema))),
-    topics: s.field("topics", topicQuerySchema),
-    // blockHash: ?s.field("blockHash", S.option(S.string)),
-  })
-
-  let fullParamsSchema = S.tuple1(paramsSchema)
-
   type log = {
     address: Address.t,
     topics: array<hex>,
-    data: hex,
     blockNumber: int,
     transactionHash: hex,
     transactionIndex: int,
     blockHash: hex,
     logIndex: int,
-    removed: bool,
   }
-
-  let logSchema = S.object((s): log => {
-    address: s.field("address", Address.schema),
-    topics: s.field("topics", S.array(S.string)),
-    data: s.field("data", S.string),
-    blockNumber: s.field("blockNumber", hexIntSchema),
-    transactionHash: s.field("transactionHash", S.string),
-    transactionIndex: s.field("transactionIndex", hexIntSchema),
-    blockHash: s.field("blockHash", S.string),
-    logIndex: s.field("logIndex", hexIntSchema),
-    removed: s.field("removed", S.bool),
-  })
-
-  let resultSchema = S.array(logSchema)
-
-  let route = makeRpcRoute("eth_getLogs", fullParamsSchema, resultSchema)
 }
 
 module GetBlockByNumber = {
@@ -230,10 +202,6 @@ module GetTransactionReceipt = {
   )
 }
 
-let getLogs = async (~client: Rest.client, ~param: GetLogs.param) => {
-  await GetLogs.route->Rest.fetch(param, ~client)
-}
-
 let getBlock = async (~client: Rest.client, ~blockNumber: int) => {
   await GetBlockByNumber.route->Rest.fetch(
     {"blockNumber": blockNumber, "includeTransactions": false},

package/src/sources/Rpc.res.mjs

@@ -4,6 +4,7 @@ import * as Rest from "../vendored/Rest.res.mjs";
 import * as Viem from "viem";
 import * as Utils from "../Utils.res.mjs";
 import * as Address from "../Address.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -48,8 +49,21 @@ async function jsonRpcFetcher(args) {
   return response;
 }
 
-function makeClient(url) {
-  return Rest.client(url, jsonRpcFetcher);
+function makeClient(url, headers) {
+  let fetcher = headers !== undefined ? async args => {
+      let headers$1 = args.headers;
+      let headers$2 = headers$1 !== undefined ? headers$1 : ({});
+      Stdlib_Dict.forEachWithKey(headers, (value, key) => {
+        headers$2[key] = value;
+      });
+      return await jsonRpcFetcher({
+        body: args.body,
+        headers: headers$2,
+        method: args.method,
+        path: args.path
+      });
+    } : jsonRpcFetcher;
+  return Rest.client(url, fetcher);
 }
 
 function makeHexSchema(fromStr) {
@@ -81,14 +95,6 @@ let decimalFloatSchema = S$RescriptSchema.transform(S$RescriptSchema.string, s =
   }
 }));
 
-let topicFilterSchema = S$RescriptSchema.union([
-  S$RescriptSchema.literal(null),
-  S$RescriptSchema.schema(s => (s.m(S$RescriptSchema.array(S$RescriptSchema.string)))),
-  S$RescriptSchema.schema(s => (s.m(S$RescriptSchema.string)))
-]);
-
-let topicQuerySchema = S$RescriptSchema.array(topicFilterSchema);
-
 function makeTopicQuery(topic0Opt, topic1Opt, topic2Opt, topic3Opt) {
   let topic0 = topic0Opt !== undefined ? topic0Opt : [];
   let topic1 = topic1Opt !== undefined ? topic1Opt : [];
@@ -130,41 +136,9 @@ function mapTopicQuery(param) {
   return makeTopicQuery(param.topic0, param.topic1, param.topic2, param.topic3);
 }
 
-let paramsSchema = S$RescriptSchema.object(s => ({
-  fromBlock: s.f("fromBlock", hexIntSchema),
-  toBlock: s.f("toBlock", hexIntSchema),
-  address: s.f("address", S$RescriptSchema.option(S$RescriptSchema.array(Address.schema))),
-  topics: s.f("topics", topicQuerySchema)
-}));
-
-let fullParamsSchema = S$RescriptSchema.tuple1(paramsSchema);
-
-let logSchema = S$RescriptSchema.object(s => ({
-  address: s.f("address", Address.schema),
-  topics: s.f("topics", S$RescriptSchema.array(S$RescriptSchema.string)),
-  data: s.f("data", S$RescriptSchema.string),
-  blockNumber: s.f("blockNumber", hexIntSchema),
-  transactionHash: s.f("transactionHash", S$RescriptSchema.string),
-  transactionIndex: s.f("transactionIndex", hexIntSchema),
-  blockHash: s.f("blockHash", S$RescriptSchema.string),
-  logIndex: s.f("logIndex", hexIntSchema),
-  removed: s.f("removed", S$RescriptSchema.bool)
-}));
-
-let resultSchema = S$RescriptSchema.array(logSchema);
-
-let route = makeRpcRoute("eth_getLogs", fullParamsSchema, resultSchema);
-
 let GetLogs = {
-  topicFilterSchema: topicFilterSchema,
-  topicQuerySchema: topicQuerySchema,
   makeTopicQuery: makeTopicQuery,
-  mapTopicQuery: mapTopicQuery,
-  paramsSchema: paramsSchema,
-  fullParamsSchema: fullParamsSchema,
-  logSchema: logSchema,
-  resultSchema: resultSchema,
-  route: route
+  mapTopicQuery: mapTopicQuery
 };
 
 let blockSchema = S$RescriptSchema.object(s => ({
@@ -190,22 +164,22 @@ let blockSchema = S$RescriptSchema.object(s => ({
   uncles: s.f("uncles", S$RescriptSchema.$$null(S$RescriptSchema.array(S$RescriptSchema.string)))
 }));
 
-let paramsSchema$1 = S$RescriptSchema.tuple(s => ({
+let paramsSchema = S$RescriptSchema.tuple(s => ({
   blockNumber: s.item(0, hexIntSchema),
   includeTransactions: s.item(1, S$RescriptSchema.bool)
 }));
 
-let resultSchema$1 = S$RescriptSchema.$$null(blockSchema);
+let resultSchema = S$RescriptSchema.$$null(blockSchema);
 
-let route$1 = makeRpcRoute("eth_getBlockByNumber", paramsSchema$1, resultSchema$1);
+let route = makeRpcRoute("eth_getBlockByNumber", paramsSchema, resultSchema);
 
-let rawRoute = makeRpcRoute("eth_getBlockByNumber", paramsSchema$1, S$RescriptSchema.$$null(S$RescriptSchema.json(false)));
+let rawRoute = makeRpcRoute("eth_getBlockByNumber", paramsSchema, S$RescriptSchema.$$null(S$RescriptSchema.json(false)));
 
 let GetBlockByNumber = {
   blockSchema: blockSchema,
-  paramsSchema: paramsSchema$1,
-  resultSchema: resultSchema$1,
-  route: route$1,
+  paramsSchema: paramsSchema,
+  resultSchema: resultSchema,
+  route: route,
   rawRoute: rawRoute
 };
 
@@ -221,12 +195,8 @@ let GetTransactionReceipt = {
   rawRoute: rawRoute$2
 };
 
-async function getLogs(client, param) {
-  return await Rest.fetch(route, param, client);
-}
-
 async function getBlock(client, blockNumber) {
-  return await Rest.fetch(route$1, {
+  return await Rest.fetch(route, {
     blockNumber: blockNumber,
     includeTransactions: false
   }, client);
@@ -252,7 +222,6 @@ export {
   GetBlockByNumber,
   GetTransactionByHash,
   GetTransactionReceipt,
-  getLogs,
   getBlock,
   getRawBlock,
 }