envio 3.3.0-alpha.4 → 3.3.0-alpha.6

package/src/SimulateItems.res.mjs

@@ -165,34 +165,6 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig) {
   }
 }
 
-function validateSrcAddresses(simulateItems, config, chainConfig, indexingAddresses) {
-  let known = new Set();
-  indexingAddresses.forEach(ia => {
-    known.add(ia.address);
-  });
-  simulateItems.forEach(rawJson => {
-    let match = rawJson.contract;
-    let match$1 = rawJson.event;
-    if (match === undefined) {
-      return;
-    }
-    if (match$1 === undefined) {
-      return;
-    }
-    let eventConfig = findEventConfig(config, match, match$1);
-    if (eventConfig === undefined) {
-      return;
-    }
-    if (eventConfig.isWildcard) {
-      return;
-    }
-    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
-    if (!known.has(srcAddress)) {
-      return Stdlib_JsError.throwWithMessage(`simulate: ` + match + `.` + match$1 + ` resolved to address ` + srcAddress + `, which isn't indexed on chain ` + chainConfig.id.toString() + `. ` + (`Provide a "srcAddress" configured or registered for ` + match + ` on this chain, or use a wildcard event.`));
-    }
-  });
-}
-
 function parse(simulateItems, config, chainConfig) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
@@ -204,7 +176,8 @@ function parse(simulateItems, config, chainConfig) {
     contents: 0
   };
   let items = [];
-  simulateItems.forEach(rawJson => {
+  let seenCoordinates = {};
+  simulateItems.forEach((rawJson, itemIndex) => {
     let match = rawJson.contract;
     let match$1 = rawJson.event;
     if (match === undefined) {
@@ -221,6 +194,9 @@ function parse(simulateItems, config, chainConfig) {
     let li = rawJson.logIndex;
     let logIndex;
     if (li !== undefined) {
+      if (li >= currentLogIndex.contents) {
+        currentLogIndex.contents = li + 1 | 0;
+      }
       logIndex = li;
     } else {
       let li$1 = currentLogIndex.contents;
@@ -272,6 +248,13 @@ function parse(simulateItems, config, chainConfig) {
         break;
     }
     currentBlock.contents = blockNumber;
+    let coordinate = blockNumber.toString() + `:` + logIndex.toString();
+    let firstIndex = seenCoordinates[coordinate];
+    if (firstIndex !== undefined) {
+      Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + chainId.toString() + ` both resolve to block ` + blockNumber.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
+    } else {
+      seenCoordinates[coordinate] = itemIndex;
+    }
     items.push({
       kind: 0,
       eventConfig: eventConfig,
@@ -360,7 +343,6 @@ export {
   dummySrcAddress,
   firstContractAddress,
   deriveSrcAddress,
-  validateSrcAddresses,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -667,11 +667,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // Parse and validate the block ranges upfront before starting any
-          // workers. srcAddress validation can't run here: it depends on which
-          // events are wildcard, and `config` reflects config.yaml only —
-          // handler-level `wildcard: true` takes effect only once registrations
-          // are applied.
+          // Parse and validate the block ranges upfront before starting any workers.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -868,26 +864,6 @@ let initTestWorker = () => {
     }
 
     let patchConfig = (config: Config.t, _registrations) => {
-      // `config` here has handler registrations applied, so `isWildcard`
-      // reflects `indexer.onEvent({ wildcard: true })` — which the main thread
-      // can't see. Validate srcAddresses against it before patching in the
-      // simulate source.
-      switch simulate {
-      | Some(simulateItems) =>
-        let chainConfig = config.chainMap->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId))
-        let indexingAddresses =
-          initialState.chains
-          ->Array.find(c => c.id == chainId)
-          ->Option.mapOr([], c => c.indexingAddresses)
-        SimulateItems.validateSrcAddresses(
-          ~simulateItems,
-          ~config,
-          ~chainConfig,
-          ~indexingAddresses,
-        )
-      | None => ()
-      }
-
       let config = SimulateItems.patchConfig(~config, ~processConfig)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
@@ -900,8 +876,8 @@ let initTestWorker = () => {
     Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)
     ->Promise.catch(exn => {
       // `Main.start` rejects on any fatal error: a runtime failure arrives wrapped
-      // in `Main.FatalError` (already logged), a setup throw (e.g. patchConfig's
-      // srcAddress validation) arrives raw. The parent only learns of failures
+      // in `Main.FatalError` (already logged), a setup throw (e.g. an invalid
+      // simulate item) arrives raw. The parent only learns of failures
       // through the worker `error` event, which fires on an *uncaught* exception.
       // Throwing synchronously in this catch would just reject the catch's own
       // promise (swallowed by `ignore`); `setImmediate` re-throws outside the

package/src/TestIndexer.res.mjs

@@ -586,11 +586,9 @@ function initTestWorker() {
     Process.exit(1);
     return;
   }
-  let initialState = workerData.initialState;
   let simulate = workerData.simulate;
   let endBlock = workerData.endBlock;
-  let chainId = workerData.chainId;
-  let chainIdStr = chainId.toString();
+  let chainIdStr = workerData.chainId.toString();
   let exitAfterFirstEventBlock = Stdlib_Option.isNone(endBlock);
   let resolvedChainDict = {};
   resolvedChainDict["startBlock"] = workerData.startBlock;
@@ -605,7 +603,7 @@ function initTestWorker() {
   let processConfig = {
     chains: resolvedChainsDict
   };
-  let proxy = TestIndexerProxyStorage.make(parentPort, initialState);
+  let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
   let config = Config.loadWithoutRegistrations();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
@@ -615,11 +613,6 @@ function initTestWorker() {
     Logging.setLogLevel("silent");
   }
   let patchConfig = (config, _registrations) => {
-    if (simulate !== undefined) {
-      let chainConfig = ChainMap.get(config.chainMap, ChainMap.Chain.makeUnsafe(chainId));
-      let indexingAddresses = Stdlib_Option.mapOr(initialState.chains.find(c => c.id === chainId), [], c => c.indexingAddresses);
-      SimulateItems.validateSrcAddresses(simulate, config, chainConfig, indexingAddresses);
-    }
     let config$1 = SimulateItems.patchConfig(config, processConfig);
     if (exitAfterFirstEventBlock) {
       return {

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 = (
@@ -31,7 +32,7 @@ let getSyncConfig = (
     intervalCeiling: Env.Configurable.SyncConfig.intervalCeiling->Option.getOr(
       intervalCeiling->Option.getOr(10_000),
     ),
-    backoffMillis: backoffMillis->Option.getOr(5000),
+    backoffMillis: backoffMillis->Option.getOr(2000),
     queryTimeoutMillis,
     fallbackStallTimeout: fallbackStallTimeout->Option.getOr(queryTimeoutMillis / 2),
     pollingInterval: pollingInterval->Option.getOr(1000),
@@ -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

@@ -13,7 +13,7 @@ function getSyncConfig(param) {
     backoffMultiplicative: Stdlib_Option.getOr(Env.Configurable.SyncConfig.backoffMultiplicative, Stdlib_Option.getOr(param.backoffMultiplicative, 0.8)),
     accelerationAdditive: Stdlib_Option.getOr(Env.Configurable.SyncConfig.accelerationAdditive, Stdlib_Option.getOr(param.accelerationAdditive, 500)),
     intervalCeiling: Stdlib_Option.getOr(Env.Configurable.SyncConfig.intervalCeiling, Stdlib_Option.getOr(param.intervalCeiling, 10000)),
-    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 5000),
+    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 2000),
     queryTimeoutMillis: queryTimeoutMillis,
     fallbackStallTimeout: Stdlib_Option.getOr(param.fallbackStallTimeout, queryTimeoutMillis / 2 | 0),
     pollingInterval: Stdlib_Option.getOr(param.pollingInterval, 1000)
@@ -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},