envio 2.9.1 → 2.11.0

package/src/bindings/Ethers.res

@@ -0,0 +1,259 @@
+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 BlockTag = {
+  type t
+
+  type semanticTag = [#latest | #earliest | #pending]
+  type hexString = string
+  type blockNumber = int
+
+  type blockTagVariant = Latest | Earliest | Pending | HexString(string) | BlockNumber(int)
+
+  let blockTagFromSemantic = (semanticTag: semanticTag): t => semanticTag->Utils.magic
+  let blockTagFromBlockNumber = (blockNumber: blockNumber): t => blockNumber->Utils.magic
+  let blockTagFromHexString = (hexString: hexString): t => hexString->Utils.magic
+
+  let blockTagFromVariant = variant =>
+    switch variant {
+    | Latest => #latest->blockTagFromSemantic
+    | Earliest => #earliest->blockTagFromSemantic
+    | Pending => #pending->blockTagFromSemantic
+    | HexString(str) => str->blockTagFromHexString
+    | BlockNumber(num) => num->blockTagFromBlockNumber
+    }
+}
+
+module EventFilter = {
+  type topic = EvmTypes.Hex.t
+  type t = {
+    address: Address.t,
+    topics: array<topic>,
+  }
+}
+module Filter = {
+  type t
+
+  //This can be used as a filter but should not assume all filters  are the same type
+  //address could be an array of addresses like in combined filter
+  type filterRecord = {
+    address: Address.t,
+    topics: array<EventFilter.topic>,
+    fromBlock: BlockTag.t,
+    toBlock: BlockTag.t,
+  }
+
+  let filterFromRecord = (filterRecord: filterRecord): t => filterRecord->Utils.magic
+}
+
+module CombinedFilter = {
+  type combinedFilterRecord = {
+    address: array<Address.t>,
+    //The second element of the tuple is the
+    topics: array<array<EventFilter.topic>>,
+    fromBlock: BlockTag.t,
+    toBlock: BlockTag.t,
+  }
+
+  let combinedFilterToFilter = (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<EventFilter.topic>,
+  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<EventFilter.topic>, 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,
+  }
+
+  type fallbackProviderOptions = {
+    // How many providers must agree on a value before reporting
+    // back the response
+    // Note: Default the half of the providers weight, so we need to set it to accept result from the first rpc
+    quorum?: int,
+  }
+
+  @module("ethers") @scope("ethers") @new
+  external makeWithOptions: (~rpcUrl: string, ~network: Network.t, ~options: rpcOptions) => t =
+    "JsonRpcProvider"
+
+  @module("ethers") @scope("ethers") @new
+  external makeFallbackProvider: (
+    ~providers: array<t>,
+    ~network: Network.t,
+    ~options: fallbackProviderOptions,
+  ) => t = "FallbackProvider"
+
+  let makeStatic = (~rpcUrl: string, ~network: Network.t, ~priority=?, ~stallTimeout=?): t => {
+    makeWithOptions(~rpcUrl, ~network, ~options={staticNetwork: network, ?priority, ?stallTimeout})
+  }
+
+  let make = (~rpcUrls: array<string>, ~chainId: int, ~fallbackStallTimeout): t => {
+    let network = Network.fromChainId(~chainId)
+    switch rpcUrls {
+    | [rpcUrl] => makeStatic(~rpcUrl, ~network)
+    | rpcUrls =>
+      makeFallbackProvider(
+        ~providers=rpcUrls->Js.Array2.mapi((rpcUrl, index) =>
+          makeStatic(~rpcUrl, ~network, ~priority=index, ~stallTimeout=fallbackStallTimeout)
+        ),
+        ~network,
+        ~options={
+          quorum: 1,
+        },
+      )
+    }
+  }
+
+  @send
+  external getLogs: (t, ~filter: Filter.t) => promise<array<log>> = "getLogs"
+
+  @send
+  external getTransaction: (t, ~transactionHash: string) => promise<transaction> = "getTransaction"
+
+  let makeGetTransactionFields = (~getTransactionByHash) => 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"]
+
+    fields->Obj.magic
+  }
+
+  type listenerEvent = [#block]
+  @send external onEventListener: (t, listenerEvent, int => unit) => unit = "on"
+
+  @send external offAllEventListeners: (t, listenerEvent) => unit = "off"
+
+  let onBlock = (t, callback: int => unit) => t->onEventListener(#block, callback)
+
+  let removeOnBlockEventListener = t => t->offAllEventListeners(#block)
+
+  @send
+  external getBlockNumber: t => promise<int> = "getBlockNumber"
+
+  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"
+}

package/src/bindings/SDSL.res

@@ -0,0 +1,12 @@
+module Queue = {
+  type t<'a>
+
+  @module("js-sdsl") @new external make: unit => t<'a> = "Queue"
+
+  type containerSize = int
+  @send external size: t<'a> => containerSize = "size"
+  @send external push: (t<'a>, 'a) => containerSize = "push"
+  @send external pop: t<'a> => option<'a> = "pop"
+  //Returns the front item without popping it
+  @send external front: t<'a> => option<'a> = "front"
+}

package/src/sources/HyperSyncJsonApi.res

@@ -0,0 +1,376 @@
+type unchecksummedEthAddress = string
+
+module QueryTypes = {
+  type blockFieldOptions =
+    | @as("number") Number
+    | @as("hash") Hash
+    | @as("parent_hash") ParentHash
+    | @as("nonce") Nonce
+    | @as("sha3_uncles") Sha3Uncles
+    | @as("logs_bloom") LogsBloom
+    | @as("transactions_root") TransactionsRoot
+    | @as("state_root") StateRoot
+    | @as("receipts_root") ReceiptsRoot
+    | @as("miner") Miner
+    | @as("difficulty") Difficulty
+    | @as("total_difficulty") TotalDifficulty
+    | @as("extra_data") ExtraData
+    | @as("size") Size
+    | @as("gas_limit") GasLimit
+    | @as("gas_used") GasUsed
+    | @as("timestamp") Timestamp
+    | @as("uncles") Uncles
+    | @as("base_fee_per_gas") BaseFeePerGas
+
+  let blockFieldOptionsSchema = Utils.Schema.enum([
+    Number,
+    Hash,
+    ParentHash,
+    Nonce,
+    Sha3Uncles,
+    LogsBloom,
+    TransactionsRoot,
+    StateRoot,
+    ReceiptsRoot,
+    Miner,
+    Difficulty,
+    TotalDifficulty,
+    ExtraData,
+    Size,
+    GasLimit,
+    GasUsed,
+    Timestamp,
+    Uncles,
+    BaseFeePerGas,
+  ])
+
+  type blockFieldSelection = array<blockFieldOptions>
+
+  let blockFieldSelectionSchema = S.array(blockFieldOptionsSchema)
+
+  type transactionFieldOptions =
+    | @as("block_hash") BlockHash
+    | @as("block_number") BlockNumber
+    | @as("from") From
+    | @as("gas") Gas
+    | @as("gas_price") GasPrice
+    | @as("hash") Hash
+    | @as("input") Input
+    | @as("nonce") Nonce
+    | @as("to") To
+    | @as("transaction_index") TransactionIndex
+    | @as("value") Value
+    | @as("v") V
+    | @as("r") R
+    | @as("s") S
+    | @as("max_priority_fee_per_gas") MaxPriorityFeePerGas
+    | @as("max_fee_per_gas") MaxFeePerGas
+    | @as("chain_id") ChainId
+    | @as("cumulative_gas_used") CumulativeGasUsed
+    | @as("effective_gas_price") EffectiveGasPrice
+    | @as("gas_used") GasUsed
+    | @as("contract_address") ContractAddress
+    | @as("logs_bloom") LogsBloom
+    | @as("type") Type
+    | @as("root") Root
+    | @as("status") Status
+    | @as("sighash") Sighash
+
+  let transactionFieldOptionsSchema = Utils.Schema.enum([
+    BlockHash,
+    BlockNumber,
+    From,
+    Gas,
+    GasPrice,
+    Hash,
+    Input,
+    Nonce,
+    To,
+    TransactionIndex,
+    Value,
+    V,
+    R,
+    S,
+    MaxPriorityFeePerGas,
+    MaxFeePerGas,
+    ChainId,
+    CumulativeGasUsed,
+    EffectiveGasPrice,
+    GasUsed,
+    ContractAddress,
+    LogsBloom,
+    Type,
+    Root,
+    Status,
+    Sighash,
+  ])
+
+  type transactionFieldSelection = array<transactionFieldOptions>
+
+  let transactionFieldSelectionSchema = S.array(transactionFieldOptionsSchema)
+
+  type logFieldOptions =
+    | @as("removed") Removed
+    | @as("log_index") LogIndex
+    | @as("transaction_index") TransactionIndex
+    | @as("transaction_hash") TransactionHash
+    | @as("block_hash") BlockHash
+    | @as("block_number") BlockNumber
+    | @as("address") Address
+    | @as("data") Data
+    | @as("topic0") Topic0
+    | @as("topic1") Topic1
+    | @as("topic2") Topic2
+    | @as("topic3") Topic3
+
+  let logFieldOptionsSchema = Utils.Schema.enum([
+    Removed,
+    LogIndex,
+    TransactionIndex,
+    TransactionHash,
+    BlockHash,
+    BlockNumber,
+    Address,
+    Data,
+    Topic0,
+    Topic1,
+    Topic2,
+    Topic3,
+  ])
+
+  type logFieldSelection = array<logFieldOptions>
+
+  let logFieldSelectionSchema = S.array(logFieldOptionsSchema)
+
+  type fieldSelection = {
+    block?: blockFieldSelection,
+    transaction?: transactionFieldSelection,
+    log?: logFieldSelection,
+  }
+
+  let fieldSelectionSchema = S.object(s => {
+    block: ?s.field("block", S.option(blockFieldSelectionSchema)),
+    transaction: ?s.field("transaction", S.option(transactionFieldSelectionSchema)),
+    log: ?s.field("log", S.option(logFieldSelectionSchema)),
+  })
+
+  type logParams = {
+    address?: array<Address.t>,
+    topics: array<array<Ethers.EventFilter.topic>>,
+  }
+
+  let logParamsSchema = S.object(s => {
+    address: ?s.field("address", S.option(S.array(Address.schema))),
+    topics: s.field("topics", S.array(S.array(EvmTypes.Hex.schema))),
+  })
+
+  type transactionParams = {
+    from?: array<Address.t>,
+    to?: array<Address.t>,
+    sighash?: array<string>,
+  }
+
+  let transactionParamsSchema = S.object(s => {
+    from: ?s.field("from", S.option(S.array(Address.schema))),
+    to: ?s.field("to", S.option(S.array(Address.schema))),
+    sighash: ?s.field("sighash", S.option(S.array(S.string))),
+  })
+
+  type postQueryBody = {
+    fromBlock: int,
+    toBlockExclusive?: int,
+    logs?: array<logParams>,
+    transactions?: array<transactionParams>,
+    fieldSelection: fieldSelection,
+    maxNumLogs?: int,
+    includeAllBlocks?: bool,
+  }
+
+  let postQueryBodySchema = S.object(s => {
+    fromBlock: s.field("from_block", S.int),
+    toBlockExclusive: ?s.field("to_block", S.option(S.int)),
+    logs: ?s.field("logs", S.option(S.array(logParamsSchema))),
+    transactions: ?s.field("transactions", S.option(S.array(transactionParamsSchema))),
+    fieldSelection: s.field("field_selection", fieldSelectionSchema),
+    maxNumLogs: ?s.field("max_num_logs", S.option(S.int)),
+    includeAllBlocks: ?s.field("include_all_blocks", S.option(S.bool)),
+  })
+}
+
+module ResponseTypes = {
+  type blockData = {
+    number?: int,
+    hash?: string,
+    parentHash?: string,
+    nonce?: option<int>,
+    sha3Uncles?: string,
+    logsBloom?: string,
+    transactionsRoot?: string,
+    stateRoot?: string,
+    receiptsRoot?: string,
+    miner?: unchecksummedEthAddress,
+    difficulty?: option<bigint>,
+    totalDifficulty?: option<bigint>,
+    extraData?: string,
+    size?: bigint,
+    gasLimit?: bigint,
+    gasUsed?: bigint,
+    timestamp?: bigint,
+    uncles?: option<string>,
+    baseFeePerGas?: option<bigint>,
+  }
+
+  let blockDataSchema = S.object(s => {
+    number: ?s.field("number", S.option(S.int)),
+    hash: ?s.field("hash", S.option(S.string)),
+    parentHash: ?s.field("parent_hash", S.option(S.string)),
+    nonce: ?s.field("nonce", S.option(S.null(S.int))),
+    sha3Uncles: ?s.field("sha3_uncles", S.option(S.string)),
+    logsBloom: ?s.field("logs_bloom", S.option(S.string)),
+    transactionsRoot: ?s.field("transactions_root", S.option(S.string)),
+    stateRoot: ?s.field("state_root", S.option(S.string)),
+    receiptsRoot: ?s.field("receipts_root", S.option(S.string)),
+    miner: ?s.field("miner", S.option(S.string)),
+    difficulty: ?s.field("difficulty", S.option(S.null(BigInt.schema))),
+    totalDifficulty: ?s.field("total_difficulty", S.option(S.null(BigInt.schema))),
+    extraData: ?s.field("extra_data", S.option(S.string)),
+    size: ?s.field("size", S.option(BigInt.schema)),
+    gasLimit: ?s.field("gas_limit", S.option(BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
+    timestamp: ?s.field("timestamp", S.option(BigInt.schema)),
+    uncles: ?s.field("unclus", S.option(S.null(S.string))),
+    baseFeePerGas: ?s.field("base_fee_per_gas", S.option(S.null(BigInt.schema))),
+  })
+
+  type transactionData = {
+    blockHash?: string,
+    blockNumber?: int,
+    from?: option<unchecksummedEthAddress>,
+    gas?: bigint,
+    gasPrice?: option<bigint>,
+    hash?: string,
+    input?: string,
+    nonce?: int,
+    to?: option<unchecksummedEthAddress>,
+    transactionIndex?: int,
+    value?: bigint,
+    v?: option<string>,
+    r?: option<string>,
+    s?: option<string>,
+    maxPriorityFeePerGas?: option<bigint>,
+    maxFeePerGas?: option<bigint>,
+    chainId?: option<int>,
+    cumulativeGasUsed?: bigint,
+    effectiveGasPrice?: bigint,
+    gasUsed?: bigint,
+    contractAddress?: option<unchecksummedEthAddress>,
+    logsBoom?: string,
+    type_?: option<int>,
+    root?: option<string>,
+    status?: option<int>,
+    sighash?: option<string>,
+  }
+
+  let transactionDataSchema = S.object(s => {
+    blockHash: ?s.field("block_hash", S.option(S.string)),
+    blockNumber: ?s.field("block_number", S.option(S.int)),
+    from: ?s.field("from", S.option(S.null(S.string))),
+    gas: ?s.field("gas", S.option(BigInt.schema)),
+    gasPrice: ?s.field("gas_price", S.option(S.null(BigInt.schema))),
+    hash: ?s.field("hash", S.option(S.string)),
+    input: ?s.field("input", S.option(S.string)),
+    nonce: ?s.field("nonce", S.option(S.int)),
+    to: ?s.field("to", S.option(S.null(S.string))),
+    transactionIndex: ?s.field("transaction_index", S.option(S.int)),
+    value: ?s.field("value", S.option(BigInt.schema)),
+    v: ?s.field("v", S.option(S.null(S.string))),
+    r: ?s.field("r", S.option(S.null(S.string))),
+    s: ?s.field("s", S.option(S.null(S.string))),
+    maxPriorityFeePerGas: ?s.field("max_priority_fee_per_gas", S.option(S.null(BigInt.schema))),
+    maxFeePerGas: ?s.field("max_fee_per_gas", S.option(S.null(BigInt.schema))),
+    chainId: ?s.field("chain_id", S.option(S.null(S.int))),
+    cumulativeGasUsed: ?s.field("cumulative_gas_used", S.option(BigInt.schema)),
+    effectiveGasPrice: ?s.field("effective_gas_price", S.option(BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
+    contractAddress: ?s.field("contract_address", S.option(S.null(S.string))),
+    logsBoom: ?s.field("logs_bloom", S.option(S.string)),
+    type_: ?s.field("type", S.option(S.null(S.int))),
+    root: ?s.field("root", S.option(S.null(S.string))),
+    status: ?s.field("status", S.option(S.null(S.int))),
+    sighash: ?s.field("sighash", S.option(S.null(S.string))),
+  })
+
+  type logData = {
+    removed?: option<bool>,
+    index?: int,
+    transactionIndex?: int,
+    transactionHash?: string,
+    blockHash?: string,
+    blockNumber?: int,
+    address?: unchecksummedEthAddress,
+    data?: string,
+    topic0?: option<Ethers.EventFilter.topic>,
+    topic1?: option<Ethers.EventFilter.topic>,
+    topic2?: option<Ethers.EventFilter.topic>,
+    topic3?: option<Ethers.EventFilter.topic>,
+  }
+
+  let logDataSchema = S.object(s => {
+    removed: ?s.field("removed", S.option(S.null(S.bool))),
+    index: ?s.field("log_index", S.option(S.int)),
+    transactionIndex: ?s.field("transaction_index", S.option(S.int)),
+    transactionHash: ?s.field("transaction_hash", S.option(S.string)),
+    blockHash: ?s.field("block_hash", S.option(S.string)),
+    blockNumber: ?s.field("block_number", S.option(S.int)),
+    address: ?s.field("address", S.option(S.string)),
+    data: ?s.field("data", S.option(S.string)),
+    topic0: ?s.field("topic0", S.option(S.null(EvmTypes.Hex.schema))),
+    topic1: ?s.field("topic1", S.option(S.null(EvmTypes.Hex.schema))),
+    topic2: ?s.field("topic2", S.option(S.null(EvmTypes.Hex.schema))),
+    topic3: ?s.field("topic3", S.option(S.null(EvmTypes.Hex.schema))),
+  })
+
+  type data = {
+    blocks?: array<blockData>,
+    transactions?: array<transactionData>,
+    logs?: array<logData>,
+  }
+
+  let dataSchema = S.object(s => {
+    blocks: ?s.field("blocks", S.array(blockDataSchema)->S.option),
+    transactions: ?s.field("transactions", S.array(transactionDataSchema)->S.option),
+    logs: ?s.field("logs", S.array(logDataSchema)->S.option),
+  })
+
+  type queryResponse = {
+    data: array<data>,
+    archiveHeight: int,
+    nextBlock: int,
+    totalTime: int,
+  }
+
+  let queryResponseSchema = S.object(s => {
+    data: s.field("data", S.array(dataSchema)),
+    archiveHeight: s.field("archive_height", S.int),
+    nextBlock: s.field("next_block", S.int),
+    totalTime: s.field("total_execution_time", S.int),
+  })
+}
+
+let queryRoute = Rest.route(() => {
+  path: "/query",
+  method: Post,
+  variables: s => s.body(QueryTypes.postQueryBodySchema),
+  responses: [
+    s => s.data(ResponseTypes.queryResponseSchema),
+  ]
+})
+
+let heightRoute = Rest.route(() => {
+  path: "/height",
+  method: Get,
+  variables: _ => (),
+  responses: [
+    s => s.field("height", S.int),
+  ]
+})