envio 2.7.3 → 2.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.7.3",
+  "version": "v2.7.5",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,20 +23,24 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.7.3",
-    "envio-linux-arm64": "v2.7.3",
-    "envio-darwin-x64": "v2.7.3",
-    "envio-darwin-arm64": "v2.7.3"
+    "envio-linux-x64": "v2.7.5",
+    "envio-linux-arm64": "v2.7.5",
+    "envio-darwin-x64": "v2.7.5",
+    "envio-darwin-arm64": "v2.7.5"
   },
   "dependencies": {
+    "@envio-dev/hypersync-client": "0.6.2",
     "rescript": "11.1.3",
-    "rescript-schema": "8.2.0"
+    "rescript-schema": "8.2.0",
+    "viem": "2.21.0"
   },
   "files": [
     "bin.js",
     "evm.schema.json",
     "fuel.schema.json",
     "rescript.json",
-    "src/**/*.res"
+    "src/**/*.res",
+    "src/**/*.resi",
+    "src/**/*.ts"
   ]
 }

package/rescript.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "namespace": true,
+  "namespace": false,
   "sources": [
     {
       "dir": "src",
@@ -12,6 +12,9 @@
     "module": "commonjs",
     "in-source": true
   },
+  "gentypeconfig": {
+    "generatedFileExtension": ".gen.ts"
+  },
   "bs-dependencies": ["rescript-schema"],
   "bsc-flags": ["-open RescriptSchema"]
 }

package/src/Address.gen.ts

@@ -0,0 +1,8 @@
+/* TypeScript file generated from Address.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import type {Address as $$t} from './bindings/OpaqueTypes.ts';
+
+export type t = $$t;

package/src/Address.res

@@ -0,0 +1,29 @@
+@genType.import(("./bindings/OpaqueTypes.ts", "Address"))
+type t
+
+let schema = S.string->S.setName("Address")->(Utils.magic: S.t<string> => S.t<t>)
+
+external toString: t => string = "%identity"
+
+external unsafeFromString: string => t = "%identity"
+
+module Evm = {
+  @module("viem")
+  external fromStringOrThrow: string => t = "getAddress"
+  // Reassign since the function might be used in the handler code
+  // and we don't want to have a "viem" import there. It's needed to keep "viem" a dependency
+  // of generated code instead of adding it to the indexer project dependencies.
+  // Also, we want a custom error message, which is searchable in our codebase.
+  let fromStringOrThrow = string => {
+    try {
+      fromStringOrThrow(string)
+    } catch {
+    | _ =>
+      Js.Exn.raiseError(
+        `Address "${string}" is invalid. Expected a 20-byte hex string starting with 0x.`,
+      )
+    }
+  }
+
+  let fromAddressOrThrow = address => address->toString->fromStringOrThrow
+}

package/src/ChainMap.resi

@@ -0,0 +1,22 @@
+module Chain: {
+  type t
+
+  external toChainId: t => int = "%identity"
+
+  let toString: t => string
+
+  let makeUnsafe: (~chainId: int) => t
+}
+
+type t<'a>
+let fromArrayUnsafe: array<(Chain.t, 'a)> => t<'a>
+let get: (t<'a>, Chain.t) => 'a
+let set: (t<'a>, Chain.t, 'a) => t<'a>
+let values: t<'a> => array<'a>
+let keys: t<'a> => array<Chain.t>
+let entries: t<'a> => array<(Chain.t, 'a)>
+let has: (t<'a>, Chain.t) => bool
+let map: (t<'a>, 'a => 'b) => t<'b>
+let mapWithKey: (t<'a>, (Chain.t, 'a) => 'b) => t<'b>
+let size: t<'a> => int
+let update: (t<'a>, Chain.t, 'a => 'a) => t<'a>

package/src/EvmTypes.res

@@ -1,7 +1,14 @@
 module Hex = {
   type t
+  /**No string validation in schema*/
+  let schema =
+    S.string->S.setName("EVM.Hex")->(Utils.magic: S.t<string> => S.t<t>)
   external fromStringUnsafe: string => t = "%identity"
   external fromStringsUnsafe: array<string> => array<t> = "%identity"
   external toString: t => string = "%identity"
   external toStrings: array<t> => array<string> = "%identity"
 }
+
+module Abi = {
+  type t
+}

package/src/Throttler.resi

@@ -0,0 +1,26 @@
+/**
+Throttles a scheduled function to run at a minimum given interval
+
+Does NOT queue scheduled functions but rather overwrites them
+on each schedule call.
+*/
+type t
+
+/**
+Creates a throttler that throttles scheduled functions to run at a minimum
+given interval in milliseconds.
+
+Does NOT queue scheduled functions but rather overwrites them
+
+The logger will be used to log any errors that occur in the scheduled
+functions.
+*/
+let make: (~intervalMillis: int, ~logger: Pino.t) => t
+
+/**
+Schedules a function to be run on a throttler, overwriting any
+previously scheduled functions. Should only be used for functions
+that do not need to be executed if there is a more up to date scheduled
+function available.
+*/
+let schedule: (t, unit => promise<unit>) => unit

package/src/bindings/HyperSyncClient.res

@@ -0,0 +1,481 @@
+type cfg = {
+  url?: string,
+  bearerToken?: string,
+  httpReqTimeoutMillis?: int,
+  maxNumRetries?: int,
+  retryBackoffMs?: int,
+  retryBaseMs?: int,
+  retryCeilingMs?: int,
+  enableChecksumAddresses?: bool,
+}
+
+module QueryTypes = {
+  type blockField =
+    | Number
+    | Hash
+    | ParentHash
+    | Nonce
+    | Sha3Uncles
+    | LogsBloom
+    | TransactionsRoot
+    | StateRoot
+    | ReceiptsRoot
+    | Miner
+    | Difficulty
+    | TotalDifficulty
+    | ExtraData
+    | Size
+    | GasLimit
+    | GasUsed
+    | Timestamp
+    | Uncles
+    | BaseFeePerGas
+    | BlobGasUsed
+    | ExcessBlobGas
+    | ParentBeaconBlockRoot
+    | WithdrawalsRoot
+    | Withdrawals
+    | L1BlockNumber
+    | SendCount
+    | SendRoot
+    | MixHash
+
+  type transactionField =
+    | BlockHash
+    | BlockNumber
+    | From
+    | Gas
+    | GasPrice
+    | Hash
+    | Input
+    | Nonce
+    | To
+    | TransactionIndex
+    | Value
+    | V
+    | R
+    | S
+    | YParity
+    | MaxPriorityFeePerGas
+    | MaxFeePerGas
+    | ChainId
+    | AccessList
+    | MaxFeePerBlobGas
+    | BlobVersionedHashes
+    | CumulativeGasUsed
+    | EffectiveGasPrice
+    | GasUsed
+    | ContractAddress
+    | LogsBloom
+    | Kind
+    | Root
+    | Status
+    | L1Fee
+    | L1GasPrice
+    | L1GasUsed
+    | L1FeeScalar
+    | GasUsedForL1
+
+  type logField =
+    | Removed
+    | LogIndex
+    | TransactionIndex
+    | TransactionHash
+    | BlockHash
+    | BlockNumber
+    | Address
+    | Data
+    | Topic0
+    | Topic1
+    | Topic2
+    | Topic3
+
+  type traceField =
+    | From
+    | To
+    | CallType
+    | Gas
+    | Input
+    | Init
+    | Value
+    | Author
+    | RewardType
+    | BlockHash
+    | BlockNumber
+    | Address
+    | Code
+    | GasUsed
+    | Output
+    | Subtraces
+    | TraceAddress
+    | TransactionHash
+    | TransactionPosition
+    | Kind
+    | Error
+
+  type fieldSelection = {
+    block?: array<blockField>,
+    transaction?: array<transactionField>,
+    log?: array<logField>,
+    trace?: array<traceField>,
+  }
+  type topicFilter = array<EvmTypes.Hex.t>
+  type topic0 = topicFilter
+  type topic1 = topicFilter
+  type topic2 = topicFilter
+  type topic3 = topicFilter
+  type topicSelection = (topic0, topic1, topic2, topic3)
+  let makeTopicSelection = (~topic0=[], ~topic1=[], ~topic2=[], ~topic3=[]) => (
+    topic0,
+    topic1,
+    topic2,
+    topic3,
+  )
+
+  type logSelection = {
+    /**
+     * Address of the contract, any logs that has any of these addresses will be returned.
+     * Empty means match all.
+     */
+    address?: array<Address.t>,
+    /**
+     * Topics to match, each member of the top level array is another array, if the nth topic matches any
+     *  topic specified in topics[n] the log will be returned. Empty means match all.
+     */
+    topics: topicSelection,
+  }
+
+  let makeLogSelection = (~address, ~topics) => {address, topics}
+
+  type transactionSelection = {
+    /**
+     * Address the transaction should originate from. If transaction.from matches any of these, the transaction
+     *  will be returned. Keep in mind that this has an and relationship with to filter, so each transaction should
+     *  match both of them. Empty means match all.
+     */
+    from?: array<Address.t>,
+    /**
+     * Address the transaction should go to. If transaction.to matches any of these, the transaction will
+     *  be returned. Keep in mind that this has an and relationship with from filter, so each transaction should
+     *  match both of them. Empty means match all.
+     */
+    @as("to")
+    to_?: array<Address.t>,
+    /** If first 4 bytes of transaction input matches any of these, transaction will be returned. Empty means match all. */
+    sighash?: array<string>,
+    /** If tx.status matches this it will be returned. */
+    status?: int,
+    /** If transaction.type matches any of these values, the transaction will be returned */
+    kind?: array<int>,
+    contractAddress?: array<Address.t>,
+  }
+
+  type traceSelection = {
+    from?: array<Address.t>,
+    @as("to") to_?: array<Address.t>,
+    address?: array<Address.t>,
+    callType?: array<string>,
+    rewardType?: array<string>,
+    kind?: array<string>,
+    sighash?: array<string>,
+  }
+
+  type blockSelection = {
+    /**
+     * Hash of a block, any blocks that have one of these hashes will be returned.
+     * Empty means match all.
+     */
+    hash?: array<string>,
+    /**
+     * Miner address of a block, any blocks that have one of these miners will be returned.
+     * Empty means match all.
+     */
+    miner?: array<Address.t>,
+  }
+
+  type joinMode = | @as(0) Default | @as(1) JoinAll | @as(2) JoinNothing
+
+  type query = {
+    /** The block to start the query from */
+    fromBlock: int,
+    /**
+     * The block to end the query at. If not specified, the query will go until the
+     *  end of data. Exclusive, the returned range will be [from_block..to_block).
+     *
+     * The query will return before it reaches this target block if it hits the time limit
+     *  configured on the server. The user should continue their query by putting the
+     *  next_block field in the response into from_block field of their next query. This implements
+     *  pagination.
+     */
+    @as("toBlock")
+    toBlockExclusive?: int,
+    /**
+     * List of log selections, these have an or relationship between them, so the query will return logs
+     * that match any of these selections.
+     */
+    logs?: array<logSelection>,
+    /**
+     * List of transaction selections, the query will return transactions that match any of these selections and
+     *  it will return transactions that are related to the returned logs.
+     */
+    transactions?: array<transactionSelection>,
+    /**
+     * List of trace selections, the query will return traces that match any of these selections and
+     *  it will re turn traces that are related to the returned logs.
+     */
+    traces?: array<traceSelection>,
+    /** List of block selections, the query will return blocks that match any of these selections */
+    blocks?: array<blockSelection>,
+    /**
+     * Field selection. The user can select which fields they are interested in, requesting less fields will improve
+     *  query execution time and reduce the payload size so the user should always use a minimal number of fields.
+     */
+    fieldSelection: fieldSelection,
+    /**
+     * Maximum number of blocks that should be returned, the server might return more blocks than this number but
+     *  it won't overshoot by too much.
+     */
+    maxNumBlocks?: int,
+    /**
+     * Maximum number of transactions that should be returned, the server might return more transactions than this number but
+     *  it won't overshoot by too much.
+     */
+    maxNumTransactions?: int,
+    /**
+     * Maximum number of logs that should be returned, the server might return more logs than this number but
+     *  it won't overshoot by too much.
+     */
+    maxNumLogs?: int,
+    /**
+     * Maximum number of traces that should be returned, the server might return more traces than this number but
+     *  it won't overshoot by too much.
+     */
+    maxNumTraces?: int,
+    /**
+     * Selects join mode for the query,
+     * Default: join in this order logs -> transactions -> traces -> blocks
+     * JoinAll: join everything to everything. For example if logSelection matches log0, we get the
+     * associated transaction of log0 and then we get associated logs of that transaction as well. Applites similarly
+     * to blocks, traces.
+     * JoinNothing: join nothing.
+     */
+    joinMode?: joinMode,
+  }
+}
+
+module ResponseTypes = {
+  type withdrawal = {
+    index?: string,
+    validatorIndex?: string,
+    address?: Address.t,
+    amount?: string,
+  }
+
+  type block = {
+    number?: int,
+    hash?: string,
+    parentHash?: string,
+    nonce?: bigint,
+    sha3Uncles?: string,
+    logsBloom?: string,
+    transactionsRoot?: string,
+    stateRoot?: string,
+    receiptsRoot?: string,
+    miner?: Address.t,
+    difficulty?: bigint,
+    totalDifficulty?: bigint,
+    extraData?: string,
+    size?: bigint,
+    gasLimit?: bigint,
+    gasUsed?: bigint,
+    timestamp?: int,
+    uncles?: array<string>,
+    baseFeePerGas?: bigint,
+    blobGasUsed?: bigint,
+    excessBlobGas?: bigint,
+    parentBeaconBlockRoot?: string,
+    withdrawalsRoot?: string,
+    withdrawals?: array<withdrawal>,
+    l1BlockNumber?: int,
+    sendCount?: string,
+    sendRoot?: string,
+    mixHash?: string,
+  }
+
+  type accessList = {
+    address?: Address.t,
+    storageKeys?: array<string>,
+  }
+
+  type transaction = {
+    blockHash?: string,
+    blockNumber?: int,
+    from?: string,
+    gas?: bigint,
+    gasPrice?: bigint,
+    hash?: string,
+    input?: string,
+    nonce?: bigint,
+    to?: string,
+    transactionIndex?: int,
+    value?: bigint,
+    v?: string,
+    r?: string,
+    s?: string,
+    yParity?: string,
+    maxPriorityFeePerGas?: bigint,
+    maxFeePerGas?: bigint,
+    chainId?: int,
+    accessList?: array<accessList>,
+    maxFeePerBlobGas?: bigint,
+    blobVersionedHashes?: array<string>,
+    cumulativeGasUsed?: bigint,
+    effectiveGasPrice?: bigint,
+    gasUsed?: bigint,
+    contractAddress?: string,
+    logsBloom?: string,
+    kind?: int,
+    root?: string,
+    status?: int,
+    l1Fee?: bigint,
+    l1GasPrice?: bigint,
+    l1GasUsed?: bigint,
+    l1FeeScalar?: int,
+    gasUsedForL1?: bigint,
+  }
+
+  type log = {
+    removed?: bool,
+    @as("logIndex") index?: int,
+    transactionIndex?: int,
+    transactionHash?: string,
+    blockHash?: string,
+    blockNumber?: int,
+    address?: Address.t,
+    data?: string,
+    topics?: array<Js.Nullable.t<EvmTypes.Hex.t>>,
+  }
+
+  type event = {
+    transaction?: transaction,
+    block?: block,
+    log: log,
+  }
+
+  type rollbackGuard = {
+    /** Block number of the last scanned block */
+    blockNumber: int,
+    /** Block timestamp of the last scanned block */
+    timestamp: int,
+    /** Block hash of the last scanned block */
+    hash: string,
+    /**
+   * Block number of the first scanned block in memory.
+   *
+   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
+   */
+    firstBlockNumber: int,
+    /**
+   * Parent hash of the first scanned block in memory.
+   *
+   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
+   */
+    firstParentHash: string,
+  }
+
+  type eventResponse = {
+    /** Current height of the source hypersync instance */
+    archiveHeight: option<int>,
+    /**
+     * Next block to query for, the responses are paginated so,
+     *  the caller should continue the query from this block if they
+     *  didn't get responses up to the to_block they specified in the Query.
+     */
+    nextBlock: int,
+    /** Total time it took the hypersync instance to execute the query. */
+    totalExecutionTime: int,
+    /** Response data */
+    data: array<event>,
+    /** Rollback guard, supposed to be used to detect rollbacks */
+    rollbackGuard: option<rollbackGuard>,
+  }
+}
+
+type query = QueryTypes.query
+type eventResponse = ResponseTypes.eventResponse
+
+//Todo, add bindings for these types
+type streamConfig
+type queryResponse
+type queryResponseStream
+type eventStream
+type t = {
+  getHeight: unit => promise<int>,
+  collect: (~query: query, ~config: streamConfig) => promise<queryResponse>,
+  collectEvents: (~query: query, ~config: streamConfig) => promise<eventResponse>,
+  collectParquet: (~path: string, ~query: query, ~config: streamConfig) => promise<unit>,
+  get: (~query: query) => promise<queryResponse>,
+  getEvents: (~query: query) => promise<eventResponse>,
+  stream: (~query: query, ~config: streamConfig) => promise<queryResponseStream>,
+  streamEvents: (~query: query, ~config: streamConfig) => promise<eventStream>,
+}
+
+@module("@envio-dev/hypersync-client") @scope("HypersyncClient") external new: cfg => t = "new"
+
+let defaultToken = "3dc856dd-b0ea-494f-b27e-017b8b6b7e07"
+
+let make = (~url, ~bearerToken: option<string>, ~httpReqTimeoutMillis, ~maxNumRetries) =>
+  new({
+    url,
+    enableChecksumAddresses: true,
+    bearerToken: bearerToken->Belt.Option.getWithDefault(defaultToken),
+    httpReqTimeoutMillis,
+    maxNumRetries,
+  })
+
+module Decoder = {
+  type rec decodedSolType<'a> = {val: 'a}
+
+  @unboxed
+  type rec decodedRaw =
+    | DecodedBool(bool)
+    | DecodedStr(string)
+    | DecodedNum(bigint)
+    | DecodedVal(decodedSolType<decodedRaw>)
+    | DecodedArr(array<decodedRaw>)
+
+  @unboxed
+  type rec decodedUnderlying =
+    | Bool(bool)
+    | Str(string)
+    | Num(bigint)
+    | Arr(array<decodedUnderlying>)
+
+  let rec toUnderlying = (d: decodedRaw): decodedUnderlying => {
+    switch d {
+    | DecodedVal(v) => v.val->toUnderlying
+    | DecodedBool(v) => Bool(v)
+    | DecodedStr(v) => Str(v)
+    | DecodedNum(v) => Num(v)
+    | DecodedArr(v) => v->Belt.Array.map(toUnderlying)->Arr
+    }
+  }
+
+  type decodedEvent = {
+    indexed: array<decodedRaw>,
+    body: array<decodedRaw>,
+  }
+
+  type log
+  type t = {
+    enableChecksummedAddresses: unit => unit,
+    disableChecksummedAddresses: unit => unit,
+    decodeLogs: array<log> => promise<array<Js.Nullable.t<decodedEvent>>>,
+    decodeLogsSync: array<log> => array<Js.Nullable.t<decodedEvent>>,
+    decodeEvents: array<ResponseTypes.event> => promise<array<Js.Nullable.t<decodedEvent>>>,
+    decodeEventsSync: array<ResponseTypes.event> => array<Js.Nullable.t<decodedEvent>>,
+  }
+
+  @module("@envio-dev/hypersync-client") @scope("Decoder")
+  external fromSignatures: array<string> => t = "fromSignatures"
+}

package/src/bindings/OpaqueTypes.ts

@@ -0,0 +1 @@
+export type Address = string;

package/src/bindings/Pino.gen.ts

@@ -0,0 +1,17 @@
+/* TypeScript file generated from Pino.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+export type logLevelUser = "udebug" | "uinfo" | "uwarn" | "uerror";
+
+export abstract class pinoMessageBlob { protected opaque!: any }; /* simulate opaque types */
+
+export type t = {
+  readonly trace: (_1:pinoMessageBlob) => void; 
+  readonly debug: (_1:pinoMessageBlob) => void; 
+  readonly info: (_1:pinoMessageBlob) => void; 
+  readonly warn: (_1:pinoMessageBlob) => void; 
+  readonly error: (_1:pinoMessageBlob) => void; 
+  readonly fatal: (_1:pinoMessageBlob) => void
+};

package/src/bindings/Viem.res

@@ -0,0 +1,28 @@
+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: bytes => 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: (bytes, ~options: sizeOptions=?) => hex = "bytesToHex"
+@module("viem") external concat: array<hex> => hex = "concat"