envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/EventRegister.res

@@ -1,241 +0,0 @@
-type registrations = {
-  onBlockByChainId: dict<array<Internal.onBlockConfig>>,
-  mutable hasEvents: bool,
-}
-
-type activeRegistration = {
-  ecosystem: Ecosystem.t,
-  multichain: Config.multichain,
-  registrations: registrations,
-  mutable finished: bool,
-}
-
-let activeRegistration = ref(None)
-
-// Might happen for tests when the handler file
-// is imported by a non-envio process (eg mocha)
-// and initialized before we started registration.
-// So we track them here to register when the startRegistration is called.
-// Theoretically we could keep preRegistration without an explicit start
-// but I want it to be this way, so for the actual indexer run
-// an error is thrown with the exact stack trace where the handler was registered.
-let preRegistered = []
-
-let withRegistration = (fn: activeRegistration => unit) => {
-  switch activeRegistration.contents {
-  | None => preRegistered->Belt.Array.push(fn)
-  | Some(r) =>
-    if r.finished {
-      Js.Exn.raiseError(
-        "The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.",
-      )
-    } else {
-      fn(r)
-    }
-  }
-}
-
-let startRegistration = (~ecosystem, ~multichain) => {
-  let r = {
-    ecosystem,
-    multichain,
-    registrations: {
-      onBlockByChainId: Js.Dict.empty(),
-      hasEvents: false,
-    },
-    finished: false,
-  }
-  activeRegistration.contents = Some(r)
-  while preRegistered->Js.Array2.length > 0 {
-    // Loop + cleanup in one go
-    switch preRegistered->Js.Array2.pop {
-    | Some(fn) => fn(r)
-    | None => ()
-    }
-  }
-}
-
-let finishRegistration = () => {
-  switch activeRegistration.contents {
-  | Some(r) => {
-      r.finished = true
-      r.registrations
-    }
-  | None =>
-    Js.Exn.raiseError("The indexer has not started registering handlers, so can't finish it.")
-  }
-}
-
-let isPendingRegistration = () => {
-  switch activeRegistration.contents {
-  | Some(r) => !r.finished
-  | None => false
-  }
-}
-
-let onBlockOptionsSchema = S.schema(s =>
-  {
-    "name": s.matches(S.string),
-    "chain": s.matches(S.int),
-    "interval": s.matches(S.option(S.int->S.intMin(1))->S.Option.getOr(1)),
-    "startBlock": s.matches(S.option(S.int)),
-    "endBlock": s.matches(S.option(S.int)),
-  }
-)
-
-let onBlock = (rawOptions: unknown, handler: Internal.onBlockArgs => promise<unit>) => {
-  withRegistration(registration => {
-    // We need to get timestamp for ordered multichain mode
-    switch registration.multichain {
-    | Unordered => ()
-    | Ordered =>
-      Js.Exn.raiseError(
-        "Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.",
-      )
-    }
-
-    let options = rawOptions->S.parseOrThrow(onBlockOptionsSchema)
-    let chainId = switch options["chain"] {
-    | chainId => chainId
-    // Dmitry: I want to add names for chains in the future
-    // and to be able to use them as a lookup.
-    // To do so, we'll need to pass a config during reigstration
-    // instead of isInitialized check.
-    }
-
-    let onBlockByChainId = registration.registrations.onBlockByChainId
-
-    switch onBlockByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->Belt.Int.toString) {
-    | None =>
-      onBlockByChainId->Utils.Dict.setByInt(
-        chainId,
-        [
-          (
-            {
-              index: 0,
-              name: options["name"],
-              startBlock: options["startBlock"],
-              endBlock: options["endBlock"],
-              interval: options["interval"],
-              chainId,
-              handler,
-            }: Internal.onBlockConfig
-          ),
-        ],
-      )
-    | Some(onBlockConfigs) =>
-      onBlockConfigs->Belt.Array.push(
-        (
-          {
-            index: onBlockConfigs->Belt.Array.length,
-            name: options["name"],
-            startBlock: options["startBlock"],
-            endBlock: options["endBlock"],
-            interval: options["interval"],
-            chainId,
-            handler,
-          }: Internal.onBlockConfig
-        ),
-      )
-    }
-  })
-}
-
-type t = {
-  contractName: string,
-  eventName: string,
-  mutable handler: option<Internal.handler>,
-  mutable contractRegister: option<Internal.contractRegister>,
-  mutable eventOptions: option<Internal.eventOptions<Js.Json.t>>,
-}
-
-let getHandler = (t: t) => t.handler
-
-let getContractRegister = (t: t) => t.contractRegister
-
-let getEventFilters = (t: t) => t.eventOptions->Belt.Option.flatMap(value => value.eventFilters)
-
-let isWildcard = (t: t) =>
-  t.eventOptions->Belt.Option.flatMap(value => value.wildcard)->Belt.Option.getWithDefault(false)
-
-let hasRegistration = ({handler, contractRegister}) =>
-  handler->Belt.Option.isSome || contractRegister->Belt.Option.isSome
-
-let make = (~contractName, ~eventName) => {
-  contractName,
-  eventName,
-  handler: None,
-  contractRegister: None,
-  eventOptions: None,
-}
-
-type eventNamespace = {contractName: string, eventName: string}
-exception DuplicateEventRegistration(eventNamespace)
-
-let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
-  switch eventOptions {
-  | Some(value) =>
-    let value =
-      value->(Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<Js.Json.t>)
-    switch t.eventOptions {
-    | None => t.eventOptions = Some(value)
-    | Some(existingValue) =>
-      if (
-        existingValue.wildcard !== value.wildcard ||
-          // TODO: Can improve the check by using deepEqual
-          existingValue.eventFilters !== value.eventFilters
-      ) {
-        let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
-        DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
-          ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
-          ~msg="Duplicate eventOptions in handlers not allowed",
-        )
-      }
-    }
-  | None => ()
-  }
-}
-
-let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(registration => {
-    registration.registrations.hasEvents = true
-    switch t.handler {
-    | None =>
-      t.handler =
-        handler
-        ->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
-        ->Some
-    | Some(_) =>
-      let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
-      DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
-        ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
-        ~msg="Duplicate registration of event handlers not allowed",
-      )
-    }
-
-    t->setEventOptions(~eventOptions, ~logger)
-  })
-}
-
-let setContractRegister = (t: t, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(registration => {
-    registration.registrations.hasEvents = true
-    switch t.contractRegister {
-    | None =>
-      t.contractRegister = Some(
-        contractRegister->(
-          Utils.magic: Internal.genericContractRegister<
-            Internal.genericContractRegisterArgs<'event, 'context>,
-          > => Internal.contractRegister
-        ),
-      )
-    | Some(_) =>
-      let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
-      DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
-        ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
-        ~msg="Duplicate contractRegister handlers not allowed",
-      )
-    }
-    t->setEventOptions(~eventOptions, ~logger)
-  })
-}

package/src/EventRegister.res.mjs

@@ -1,240 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Logging from "./Logging.res.mjs";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as ErrorHandling from "./ErrorHandling.res.mjs";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-
-var activeRegistration = {
-  contents: undefined
-};
-
-var preRegistered = [];
-
-function withRegistration(fn) {
-  var r = activeRegistration.contents;
-  if (r !== undefined) {
-    if (r.finished) {
-      return Js_exn.raiseError("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
-    } else {
-      return fn(r);
-    }
-  } else {
-    preRegistered.push(fn);
-    return ;
-  }
-}
-
-function startRegistration(ecosystem, multichain) {
-  var r = {
-    ecosystem: ecosystem,
-    multichain: multichain,
-    registrations: {
-      onBlockByChainId: {},
-      hasEvents: false
-    },
-    finished: false
-  };
-  activeRegistration.contents = r;
-  while(preRegistered.length > 0) {
-    var fn = preRegistered.pop();
-    if (fn !== undefined) {
-      fn(r);
-    }
-    
-  };
-}
-
-function finishRegistration() {
-  var r = activeRegistration.contents;
-  if (r !== undefined) {
-    r.finished = true;
-    return r.registrations;
-  } else {
-    return Js_exn.raiseError("The indexer has not started registering handlers, so can't finish it.");
-  }
-}
-
-function isPendingRegistration() {
-  var r = activeRegistration.contents;
-  if (r !== undefined) {
-    return !r.finished;
-  } else {
-    return false;
-  }
-}
-
-var onBlockOptionsSchema = S$RescriptSchema.schema(function (s) {
-      return {
-              name: s.m(S$RescriptSchema.string),
-              chain: s.m(S$RescriptSchema.$$int),
-              interval: s.m(S$RescriptSchema.$$Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.$$int, 1, undefined)), 1)),
-              startBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
-              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
-            };
-    });
-
-function onBlock(rawOptions, handler) {
-  withRegistration(function (registration) {
-        var match = registration.multichain;
-        if (match === "ordered") {
-          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
-        }
-        var options = S$RescriptSchema.parseOrThrow(rawOptions, onBlockOptionsSchema);
-        var chainId = options.chain;
-        var onBlockByChainId = registration.registrations.onBlockByChainId;
-        var onBlockConfigs = onBlockByChainId[String(chainId)];
-        if (onBlockConfigs !== undefined) {
-          onBlockConfigs.push({
-                index: onBlockConfigs.length,
-                name: options.name,
-                chainId: chainId,
-                startBlock: options.startBlock,
-                endBlock: options.endBlock,
-                interval: options.interval,
-                handler: handler
-              });
-        } else {
-          onBlockByChainId[chainId] = [{
-              index: 0,
-              name: options.name,
-              chainId: chainId,
-              startBlock: options.startBlock,
-              endBlock: options.endBlock,
-              interval: options.interval,
-              handler: handler
-            }];
-        }
-      });
-}
-
-function getHandler(t) {
-  return t.handler;
-}
-
-function getContractRegister(t) {
-  return t.contractRegister;
-}
-
-function getEventFilters(t) {
-  return Belt_Option.flatMap(t.eventOptions, (function (value) {
-                return value.eventFilters;
-              }));
-}
-
-function isWildcard(t) {
-  return Belt_Option.getWithDefault(Belt_Option.flatMap(t.eventOptions, (function (value) {
-                    return value.wildcard;
-                  })), false);
-}
-
-function hasRegistration(param) {
-  var handler = param.handler;
-  var contractRegister = param.contractRegister;
-  if (Belt_Option.isSome(handler)) {
-    return true;
-  } else {
-    return Belt_Option.isSome(contractRegister);
-  }
-}
-
-function make(contractName, eventName) {
-  return {
-          contractName: contractName,
-          eventName: eventName,
-          handler: undefined,
-          contractRegister: undefined,
-          eventOptions: undefined
-        };
-}
-
-var DuplicateEventRegistration = /* @__PURE__ */Caml_exceptions.create("EventRegister.DuplicateEventRegistration");
-
-function setEventOptions(t, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  if (eventOptions === undefined) {
-    return ;
-  }
-  var existingValue = t.eventOptions;
-  if (existingValue === undefined) {
-    t.eventOptions = eventOptions;
-    return ;
-  }
-  if (!(existingValue.wildcard !== eventOptions.wildcard || existingValue.eventFilters !== eventOptions.eventFilters)) {
-    return ;
-  }
-  var eventNamespace_contractName = t.contractName;
-  var eventNamespace_eventName = t.eventName;
-  var eventNamespace = {
-    contractName: eventNamespace_contractName,
-    eventName: eventNamespace_eventName
-  };
-  ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate eventOptions in handlers not allowed", {
-        RE_EXN_ID: DuplicateEventRegistration,
-        _1: eventNamespace
-      });
-}
-
-function setHandler(t, handler, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (registration) {
-        registration.registrations.hasEvents = true;
-        var match = t.handler;
-        if (match !== undefined) {
-          var eventNamespace_contractName = t.contractName;
-          var eventNamespace_eventName = t.eventName;
-          var eventNamespace = {
-            contractName: eventNamespace_contractName,
-            eventName: eventNamespace_eventName
-          };
-          ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate registration of event handlers not allowed", {
-                RE_EXN_ID: DuplicateEventRegistration,
-                _1: eventNamespace
-              });
-        } else {
-          t.handler = handler;
-        }
-        setEventOptions(t, eventOptions, logger);
-      });
-}
-
-function setContractRegister(t, contractRegister, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (registration) {
-        registration.registrations.hasEvents = true;
-        var match = t.contractRegister;
-        if (match !== undefined) {
-          var eventNamespace_contractName = t.contractName;
-          var eventNamespace_eventName = t.eventName;
-          var eventNamespace = {
-            contractName: eventNamespace_contractName,
-            eventName: eventNamespace_eventName
-          };
-          ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate contractRegister handlers not allowed", {
-                RE_EXN_ID: DuplicateEventRegistration,
-                _1: eventNamespace
-              });
-        } else {
-          t.contractRegister = contractRegister;
-        }
-        setEventOptions(t, eventOptions, logger);
-      });
-}
-
-export {
-  startRegistration ,
-  isPendingRegistration ,
-  finishRegistration ,
-  make ,
-  setHandler ,
-  setContractRegister ,
-  getHandler ,
-  getContractRegister ,
-  getEventFilters ,
-  isWildcard ,
-  hasRegistration ,
-  onBlock ,
-}
-/* onBlockOptionsSchema Not a pure module */

package/src/bindings/Ethers.gen.ts

@@ -1,14 +0,0 @@
-/* TypeScript file generated from Ethers.res by genType. */
-
-/* eslint-disable */
-/* tslint:disable */
-
-import * as EthersJS from './Ethers.res.mjs';
-
-import type {t as Address_t} from '../../src/Address.gen.js';
-
-export const Addresses_mockAddresses: Address_t[] = EthersJS.Addresses.mockAddresses as any;
-
-export const Addresses_defaultAddress: Address_t = EthersJS.Addresses.defaultAddress as any;
-
-export const Addresses: { mockAddresses: Address_t[]; defaultAddress: Address_t } = EthersJS.Addresses as any;

package/src/bindings/Ethers.res

@@ -1,204 +0,0 @@
-type abi = EvmTypes.Abi.t
-
-let makeAbi = (abi: Js.Json.t): abi => abi->Utils.magic
-
-@deprecated("Use Address.t instead. The type will be removed in v3")
-type ethAddress = Address.t
-@deprecated("Use Address.Evm.fromStringOrThrow instead. The function will be removed in v3")
-let getAddressFromStringUnsafe = Address.Evm.fromStringOrThrow
-@deprecated("Use Address.toString instead. The function will be removed in v3")
-let ethAddressToString = Address.toString
-@deprecated("Use Address.schema instead. The function will be removed in v3")
-let ethAddressSchema = Address.schema
-
-type txHash = string
-
-module Constants = {
-  @module("ethers") @scope("ethers") external zeroHash: string = "ZeroHash"
-  @module("ethers") @scope("ethers") external zeroAddress: Address.t = "ZeroAddress"
-}
-
-module Addresses = {
-  @genType
-  let mockAddresses = [
-    "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
-    "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-    "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
-    "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
-    "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
-    "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
-    "0x14dC79964da2C08b23698B3D3cc7Ca32193d9955",
-    "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f",
-    "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720",
-    "0xBcd4042DE499D14e55001CcbB24a551F3b954096",
-    "0x71bE63f3384f5fb98995898A86B02Fb2426c5788",
-    "0xFABB0ac9d68B0B445fB7357272Ff202C5651694a",
-    "0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec",
-    "0xdF3e18d64BC6A983f673Ab319CCaE4f1a57C7097",
-    "0xcd3B766CCDd6AE721141F452C550Ca635964ce71",
-    "0x2546BcD3c84621e976D8185a91A922aE77ECEc30",
-    "0xbDA5747bFD65F08deb54cb465eB87D40e51B197E",
-    "0xdD2FD4581271e230360230F9337D5c0430Bf44C0",
-    "0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199",
-  ]->Belt.Array.map(getAddressFromStringUnsafe)
-  @genType
-  let defaultAddress =
-    mockAddresses[0]
-}
-
-module Filter = {
-  type t
-}
-
-module CombinedFilter = {
-  type combinedFilterRecord = {
-    address?: array<Address.t>,
-    //The second element of the tuple is the
-    topics: Rpc.GetLogs.topicQuery,
-    fromBlock: int,
-    toBlock: int,
-  }
-
-  let toFilter = (combinedFilter: combinedFilterRecord): Filter.t => combinedFilter->Utils.magic
-}
-
-type log = {
-  blockNumber: int,
-  blockHash: string,
-  removed: option<bool>,
-  //Note: this is the index of the log in the transaction and should be used whenever we use "logIndex"
-  address: Address.t,
-  data: string,
-  topics: array<EvmTypes.Hex.t>,
-  transactionHash: txHash,
-  transactionIndex: int,
-  //Note: this logIndex is the index of the log in the block, not the transaction
-  @as("index") logIndex: int,
-}
-
-type transaction
-
-type minimumParseableLogData = {topics: array<EvmTypes.Hex.t>, data: string}
-
-//Can safely convert from log to minimumParseableLogData since it contains
-//both data points required
-let logToMinimumParseableLogData: log => minimumParseableLogData = Utils.magic
-
-type logDescription<'a> = {
-  args: 'a,
-  name: string,
-  signature: string,
-  topic: string,
-}
-
-module Network = {
-  type t
-
-  @module("ethers") @new
-  external make: (~name: string, ~chainId: int) => t = "Network"
-
-  @module("ethers") @scope("Network")
-  external fromChainId: (~chainId: int) => t = "from"
-}
-
-module JsonRpcProvider = {
-  type t
-
-  type rpcOptions = {
-    staticNetwork?: Network.t,
-    // Options for FallbackProvider
-    /**
-     *  The amount of time to wait before kicking off the next provider.
-     *
-     *  Any providers that have not responded can still respond and be
-     *  counted, but this ensures new providers start.
-     *  Default: 400ms
-     */
-    stallTimeout?: int,
-    /**
-     *  The priority. Lower priority providers are dispatched first.
-     *  Default: 1
-     */
-    priority?: int,
-    /**
-     *  The amount of weight a provider is given against the quorum.
-     *  Default: 1
-     */
-    weight?: int,
-  }
-
-  @module("ethers") @scope("ethers") @new
-  external makeWithOptions: (~rpcUrl: string, ~network: Network.t, ~options: rpcOptions) => t =
-    "JsonRpcProvider"
-
-  let makeStatic = (~rpcUrl: string, ~network: Network.t, ~priority=?, ~stallTimeout=?): t => {
-    makeWithOptions(~rpcUrl, ~network, ~options={staticNetwork: network, ?priority, ?stallTimeout})
-  }
-
-  let make = (~rpcUrl: string, ~chainId: int): t => {
-    let network = Network.fromChainId(~chainId)
-    makeStatic(~rpcUrl, ~network)
-  }
-
-  @send
-  external getLogs: (t, ~filter: Filter.t) => promise<array<log>> = "getLogs"
-
-  @send
-  external getTransaction: (t, ~transactionHash: string) => promise<transaction> = "getTransaction"
-
-  let makeGetTransactionFields = (~getTransactionByHash, ~lowercaseAddresses: bool) => async (
-    log: log,
-  ): promise<unknown> => {
-    let transaction = await getTransactionByHash(log.transactionHash)
-    // Mutating should be fine, since the transaction isn't used anywhere else outside the function
-    let fields: {..} = transaction->Obj.magic
-
-    // Make it compatible with HyperSync transaction fields
-    fields["transactionIndex"] = log.transactionIndex
-    fields["input"] = fields["data"]
-
-    // NOTE: this is wasteful if these fields are not selected in the users config.
-    //       There might be a better way to do this in the `makeThrowingGetEventTransaction` function rather based on the schema.
-    //       However this is not extremely expensive and good enough for now (only on rpc sync also).
-    if lowercaseAddresses {
-      open Js.Nullable
-      switch fields["from"] {
-      | Value(from) => fields["from"] = from->Js.String2.toLowerCase
-      | Undefined => ()
-      | Null => ()
-      }
-      switch fields["to"] {
-      | Value(to) => fields["to"] = to->Js.String2.toLowerCase
-      | Undefined => ()
-      | Null => ()
-      }
-      switch fields["contractAddress"] {
-      | Value(contractAddress) =>
-        fields["contractAddress"] = contractAddress->Js.String2.toLowerCase
-      | Undefined => ()
-      | Null => ()
-      }
-    }
-
-    fields->Obj.magic
-  }
-
-  type block = {
-    _difficulty: bigint,
-    difficulty: int,
-    extraData: Address.t,
-    gasLimit: bigint,
-    gasUsed: bigint,
-    hash: string,
-    miner: Address.t,
-    nonce: int,
-    number: int,
-    parentHash: Address.t,
-    timestamp: int,
-    transactions: array<Address.t>,
-  }
-
-  @send
-  external getBlock: (t, int) => promise<Js.nullable<block>> = "getBlock"
-}