envio 2.14.3 → 2.16.0

package/README.md

@@ -14,17 +14,17 @@ HyperIndex is a fast, developer-friendly multichain indexer, optimized for both
 - **[Indexer auto-generation](https://docs.envio.dev/docs/HyperIndex/contract-import)** – Generate Indexers directly from smart contract addresses
 - **High performance** – Historical backfills at over 5,000+ events per second ([fastest in market](https://docs.envio.dev/blog/indexer-benchmarking-results))
 - **Local development** – Full-featured local environment with Docker
-- **Multichain indexing** – Index any EVM-compatible blockchain and Fuel (simultaneously)
+- **[Multichain indexing](https://docs.envio.dev/docs/HyperIndex/multichain-indexing)** – Index any EVM-compatible blockchain and Fuel (simultaneously)
 - **Real-time indexing** – Instantly track blockchain events
-- **Reorg support** – Graceful handling of blockchain reorganizations
+- **[Reorg support](https://docs.envio.dev/docs/HyperIndex/reorgs-support)** – Graceful handling of blockchain reorganizations
 - **GraphQL API** – Easy-to-query indexed data
 - **Flexible language support** – JavaScript, TypeScript, and ReScript
 - **Factory contract support** – Index data from 100,000+ factory contracts seamlessly
 - **On-chain & off-chain data integration** – Easily combine multiple data sources
-- **Self-hosted & managed options** – Run your own setup or use HyperIndex hosted services
+- **[Self-hosted & managed options](https://docs.envio.dev/docs/HyperIndex/hosted-service)** – Run your own setup or use HyperIndex hosted services
 - **Detailed logging & error reporting** – Debug and optimize with clarity
 - **External API actions** – Trigger external services based on blockchain events
-- **Wildcard topic indexing** – Flexible indexing based on event topics
+- **[Wildcard topic indexing](https://docs.envio.dev/docs/HyperIndex/wildcard-indexing)** – Flexible indexing based on event topics
 - **Fallback RPC data sources** – Enhanced reliability with RPC connections
 
 ## Getting Started

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.14.3",
+  "version": "v2.16.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,10 +23,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.14.3",
-    "envio-linux-arm64": "v2.14.3",
-    "envio-darwin-x64": "v2.14.3",
-    "envio-darwin-arm64": "v2.14.3"
+    "envio-linux-x64": "v2.16.0",
+    "envio-linux-arm64": "v2.16.0",
+    "envio-darwin-x64": "v2.16.0",
+    "envio-darwin-arm64": "v2.16.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",

package/src/Internal.gen.ts

@@ -3,6 +3,8 @@
 /* eslint-disable */
 /* tslint:disable */
 
+import type {invalid as $$noEventFilters} from './bindings/OpaqueTypes.ts';
+
 import type {t as Address_t} from './Address.gen';
 
 export type genericEvent<params,block,transaction> = {
@@ -45,3 +47,5 @@ export type fuelTransferParams = {
   readonly assetId: string; 
   readonly amount: bigint
 };
+
+export type noEventFilters = $$noEventFilters;

package/src/Internal.res

@@ -64,22 +64,23 @@ type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
   preRegisterDynamicContracts?: bool,
 }
 
-type eventItem = {
-  eventName: string,
+// This is private so it's not manually constructed internally
+// The idea is that it can only be coerced from fuel/evmEventConfig
+// and it can include their fields. We prevent manual creation,
+// so the fields are not overwritten and we can safely cast the type back to fuel/evmEventConfig
+type eventConfig = private {
+  id: string,
+  name: string,
   contractName: string,
+  isWildcard: bool,
+  // Usually always false for wildcard events
+  // But might be true for wildcard event with dynamic event filter by addresses
+  dependsOnAddresses: bool,
+  preRegisterDynamicContracts: bool,
   loader: option<loader>,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
-  timestamp: int,
-  chain: ChainMap.Chain.t,
-  blockNumber: int,
-  logIndex: int,
-  event: event,
   paramsRawEventSchema: S.schema<eventParams>,
-  //Default to false, if an event needs to
-  //be reprocessed after it has loaded dynamic contracts
-  //This gets set to true and does not try and reload events
-  hasRegisteredDynamicContracts?: bool,
 }
 
 type fuelEventKind =
@@ -89,20 +90,52 @@ type fuelEventKind =
   | Transfer
   | Call
 type fuelEventConfig = {
-  name: string,
-  contractName: string,
+  ...eventConfig,
   kind: fuelEventKind,
-  isWildcard: bool,
-  loader: option<loader>,
-  handler: option<handler>,
-  contractRegister: option<contractRegister>,
-  paramsRawEventSchema: S.schema<eventParams>,
 }
 type fuelContractConfig = {
   name: string,
   events: array<fuelEventConfig>,
 }
 
+type topicSelection = {
+  topic0: array<EvmTypes.Hex.t>,
+  topic1: array<EvmTypes.Hex.t>,
+  topic2: array<EvmTypes.Hex.t>,
+  topic3: array<EvmTypes.Hex.t>,
+}
+
+type eventFiltersArgs = {chainId: int, addresses: array<Address.t>}
+
+type eventFilters =
+  Static(array<topicSelection>) | Dynamic(array<Address.t> => array<topicSelection>)
+
+type evmEventConfig = {
+  ...eventConfig,
+  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
+  blockSchema: S.schema<eventBlock>,
+  transactionSchema: S.schema<eventTransaction>,
+  convertHyperSyncEventArgs: HyperSyncClient.Decoder.decodedEvent => eventParams,
+}
+type evmContractConfig = {
+  name: string,
+  abi: EvmTypes.Abi.t,
+  events: array<evmEventConfig>,
+}
+
+type eventItem = {
+  eventConfig: eventConfig,
+  timestamp: int,
+  chain: ChainMap.Chain.t,
+  blockNumber: int,
+  logIndex: int,
+  event: event,
+  //Default to false, if an event needs to
+  //be reprocessed after it has loaded dynamic contracts
+  //This gets set to true and does not try and reload events
+  hasRegisteredDynamicContracts?: bool,
+}
+
 @genType
 type fuelSupplyParams = {
   subId: string,
@@ -125,3 +158,6 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
+
+@genType.import(("./bindings/OpaqueTypes.ts", "invalid"))
+type noEventFilters

package/src/LogSelection.res

@@ -1,24 +1,17 @@
-type topicSelection = {
-  topic0: array<EvmTypes.Hex.t>,
-  topic1: array<EvmTypes.Hex.t>,
-  topic2: array<EvmTypes.Hex.t>,
-  topic3: array<EvmTypes.Hex.t>,
-}
-
 exception MissingRequiredTopic0
 let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]) =>
   if topic0->Utils.Array.isEmpty {
     Error(MissingRequiredTopic0)
   } else {
     {
-      topic0,
+      Internal.topic0,
       topic1,
       topic2,
       topic3,
     }->Ok
   }
 
-let hasFilters = ({topic1, topic2, topic3}: topicSelection) => {
+let hasFilters = ({topic1, topic2, topic3}: Internal.topicSelection) => {
   [topic1, topic2, topic3]->Js.Array2.find(topic => !Utils.Array.isEmpty(topic))->Belt.Option.isSome
 }
 
@@ -26,7 +19,7 @@ let hasFilters = ({topic1, topic2, topic3}: topicSelection) => {
 For a group of topic selections, if multiple only use topic0, then they can be compressed into one
 selection combining the topic0s
 */
-let compressTopicSelections = (topicSelections: array<topicSelection>) => {
+let compressTopicSelections = (topicSelections: array<Internal.topicSelection>) => {
   let topic0sOfSelectionsWithoutFilters = []
 
   let selectionsWithFilters = []
@@ -45,7 +38,7 @@ let compressTopicSelections = (topicSelections: array<topicSelection>) => {
   | [] => selectionsWithFilters
   | topic0 =>
     let selectionWithoutFilters = {
-      topic0,
+      Internal.topic0,
       topic1: [],
       topic2: [],
       topic3: [],
@@ -56,10 +49,131 @@ let compressTopicSelections = (topicSelections: array<topicSelection>) => {
 
 type t = {
   addresses: array<Address.t>,
-  topicSelections: array<topicSelection>,
+  topicSelections: array<Internal.topicSelection>,
 }
 
 let make = (~addresses, ~topicSelections) => {
   let topicSelections = compressTopicSelections(topicSelections)
   {addresses, topicSelections}
 }
+
+type parsedEventFilters = {
+  getEventFiltersOrThrow: ChainMap.Chain.t => Internal.eventFilters,
+  dependsOnAddresses: bool,
+}
+
+let parseEventFiltersOrThrow = {
+  let emptyTopics = []
+  let noopGetter = _ => emptyTopics
+
+  (
+    ~eventFilters: option<Js.Json.t>,
+    ~sighash,
+    ~params,
+    ~topic1=noopGetter,
+    ~topic2=noopGetter,
+    ~topic3=noopGetter,
+  ): parsedEventFilters => {
+    let dependsOnAddresses = ref(false)
+    let topic0 = [sighash->EvmTypes.Hex.fromStringUnsafe]
+    let default = {
+      Internal.topic0,
+      topic1: emptyTopics,
+      topic2: emptyTopics,
+      topic3: emptyTopics,
+    }
+
+    let parse = (eventFilters: Js.Json.t): array<Internal.topicSelection> => {
+      switch eventFilters {
+      | Array([]) => [%raw(`{}`)]
+      | Array(a) => a
+      | _ => [eventFilters]
+      }->Js.Array2.map(eventFilter => {
+        switch eventFilter {
+        | Object(eventFilter) => {
+            let filterKeys = eventFilter->Js.Dict.keys
+            switch filterKeys {
+            | [] => default
+            | _ => {
+                filterKeys->Js.Array2.forEach(key => {
+                  if params->Js.Array2.includes(key)->not {
+                    // In TS type validation doesn't catch this
+                    // when we have eventFilters as a callback
+                    Js.Exn.raiseError(
+                      `Invalid event filters configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
+                    )
+                  }
+                })
+                {
+                  Internal.topic0,
+                  topic1: topic1(eventFilter),
+                  topic2: topic2(eventFilter),
+                  topic3: topic3(eventFilter),
+                }
+              }
+            }
+          }
+        | _ => Js.Exn.raiseError("Invalid event filters configuration. Expected an object")
+        }
+      })
+    }
+
+    let getEventFiltersOrThrow = switch eventFilters {
+    | None => {
+        let static: Internal.eventFilters = Static([default])
+        _ => static
+      }
+    | Some(eventFilters) =>
+      if Js.typeof(eventFilters) === "function" {
+        let fn = eventFilters->(Utils.magic: Js.Json.t => Internal.eventFiltersArgs => Js.Json.t)
+        // When user passess a function to event filters we need to
+        // first determine whether it uses addresses or not
+        // Because the fetching logic will be different for wildcard events
+        // 1. If wildcard event doesn't use addresses,
+        //    it should start fetching even without static addresses in the config
+        // 2. If wildcard event uses addresses in event filters,
+        //    it should first wait for dynamic contract registration
+        // So to deterimine which case we run the function with dummy args
+        // and check if it uses addresses by using the getter.
+        try {
+          let args = (
+            {
+              chainId: 0,
+              addresses: [],
+            }: Internal.eventFiltersArgs
+          )->Utils.Object.defineProperty(
+            "addresses",
+            {
+              get: () => {
+                dependsOnAddresses := true
+                []
+              },
+            },
+          )
+          let _ = fn(args)
+        } catch {
+        | _ => ()
+        }
+        if dependsOnAddresses.contents {
+          chain => Internal.Dynamic(
+            addresses => fn({chainId: chain->ChainMap.Chain.toChainId, addresses})->parse,
+          )
+        } else {
+          // When we don't depend on addresses, can mark the event filter
+          // as static and avoid recalculating on every batch
+          chain => Internal.Static(
+            fn({chainId: chain->ChainMap.Chain.toChainId, addresses: []})->parse,
+          )
+        }
+      } else {
+        let static: Internal.eventFilters = Static(eventFilters->parse)
+        _ => static
+      }
+    }
+
+    {
+      getEventFiltersOrThrow,
+      dependsOnAddresses: dependsOnAddresses.contents,
+    }
+  }
+}

package/src/Utils.res

@@ -7,6 +7,21 @@ let delay = milliseconds =>
     }, milliseconds)
   })
 
+module Object = {
+  // Define a type for the property descriptor
+  type propertyDescriptor<'a> = {
+    configurable?: bool,
+    enumerable?: bool,
+    writable?: bool,
+    value?: 'a,
+    get?: unit => 'a,
+    set?: 'a => unit,
+  }
+
+  @val @scope("Object")
+  external defineProperty: ('obj, string, propertyDescriptor<'a>) => 'obj = "defineProperty"
+}
+
 module Option = {
   let mapNone = (opt: option<'a>, val: 'b): option<'b> => {
     switch opt {
@@ -50,6 +65,20 @@ module Dict = {
    */
   external dangerouslyGetNonOption: (dict<'a>, string) => option<'a> = ""
 
+  let push = (dict, key, value) => {
+    switch dict->dangerouslyGetNonOption(key) {
+    | Some(arr) => arr->Js.Array2.push(value)->ignore
+    | None => dict->Js.Dict.set(key, [value])
+    }
+  }
+
+  let pushMany = (dict, key, values) => {
+    switch dict->dangerouslyGetNonOption(key) {
+    | Some(arr) => arr->Js.Array2.pushMany(values)->ignore
+    | None => dict->Js.Dict.set(key, values)
+    }
+  }
+
   let merge: (dict<'a>, dict<'a>) => dict<'a> = %raw(`(dictA, dictB) => ({...dictA, ...dictB})`)
 
   let map = (dict, fn) => {
@@ -267,8 +296,6 @@ let unwrapResultExn = res =>
 external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 
 module Schema = {
-  let enum = S.enum
-
   let getNonOptionalFieldNames = schema => {
     let acc = []
     switch schema->S.classify {

package/src/bindings/Ethers.res

@@ -55,7 +55,7 @@ module CombinedFilter = {
   type combinedFilterRecord = {
     address?: array<Address.t>,
     //The second element of the tuple is the
-    topics: array<array<EvmTypes.Hex.t>>,
+    topics: Rpc.GetLogs.topicQuery,
     fromBlock: int,
     toBlock: int,
   }
@@ -147,17 +147,18 @@ module JsonRpcProvider = {
   @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
+  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"]
+      // Make it compatible with HyperSync transaction fields
+      fields["transactionIndex"] = log.transactionIndex
+      fields["input"] = fields["data"]
 
-    fields->Obj.magic
-  }
+      fields->Obj.magic
+    }
 
   type block = {
     _difficulty: bigint,

package/src/bindings/OpaqueTypes.ts

@@ -1 +1,2 @@
 export type Address = string;
+export type invalid = never;

package/src/sources/HyperSyncClient.res

@@ -422,13 +422,11 @@ type t = {
 
 @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) =>
+let make = (~url, ~apiToken, ~httpReqTimeoutMillis, ~maxNumRetries) =>
   new({
     url,
     enableChecksumAddresses: true,
-    bearerToken: bearerToken->Belt.Option.getWithDefault(defaultToken),
+    bearerToken: apiToken,
     httpReqTimeoutMillis,
     maxNumRetries,
   })

package/src/sources/HyperSyncJsonApi.res

@@ -360,13 +360,17 @@ module ResponseTypes = {
 let queryRoute = Rest.route(() => {
   path: "/query",
   method: Post,
-  input: s => s.body(QueryTypes.postQueryBodySchema),
+  input: s =>
+    {
+      "query": s.body(QueryTypes.postQueryBodySchema),
+      "token": s.auth(Bearer),
+    },
   responses: [s => s.data(ResponseTypes.queryResponseSchema)],
 })
 
 let heightRoute = Rest.route(() => {
   path: "/height",
   method: Get,
-  input: _ => (),
+  input: s => s.auth(Bearer),
   responses: [s => s.field("height", S.int)],
 })

package/src/sources/Rpc.res

@@ -71,7 +71,7 @@ module GetLogs = {
     topics->Belt.Array.map(toTopicFilter)
   }
 
-  let mapTopicQuery = ({topic0, topic1, topic2, topic3}: LogSelection.topicSelection): topicQuery =>
+  let mapTopicQuery = ({topic0, topic1, topic2, topic3}: Internal.topicSelection): topicQuery =>
     makeTopicQuery(~topic0, ~topic1, ~topic2, ~topic3)
 
   type param = {