envio 2.14.3 → 2.15.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.15.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.15.0",
+    "envio-linux-arm64": "v2.15.0",
+    "envio-darwin-x64": "v2.15.0",
+    "envio-darwin-arm64": "v2.15.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,16 @@ type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
   preRegisterDynamicContracts?: bool,
 }
 
-type eventItem = {
-  eventName: string,
+type baseEventConfig = {
+  id: string,
+  name: string,
   contractName: string,
+  isWildcard: 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 +83,47 @@ type fuelEventKind =
   | Transfer
   | Call
 type fuelEventConfig = {
-  name: string,
-  contractName: string,
+  ...baseEventConfig,
   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 evmEventConfig = {
+  ...baseEventConfig,
+  getTopicSelectionsOrThrow: (~chain: ChainMap.Chain.t) => array<topicSelection>,
+  blockSchema: S.schema<eventBlock>,
+  transactionSchema: S.schema<eventTransaction>,
+  convertHyperSyncEventArgs: HyperSyncClient.Decoder.decodedEvent => eventParams,
+}
+type evmContractConfig = {
+  name: string,
+  abi: Ethers.abi,
+  events: array<evmEventConfig>,
+}
+
+type eventItem = {
+  eventConfig: baseEventConfig,
+  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 +146,8 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
+
+@genType.import(("./bindings/OpaqueTypes.ts", "invalid"))
+type noEventFilters
+type eventFilters
+type eventFiltersArgs = {chainId: int}

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,61 @@ 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}
 }
+
+let fromEventFiltersOrThrow = {
+  let emptyTopics = []
+  let noopGetter = _ => emptyTopics
+
+  (
+    ~chain,
+    ~eventFilters: option<Js.Json.t>,
+    ~sighash,
+    ~topic1=noopGetter,
+    ~topic2=noopGetter,
+    ~topic3=noopGetter,
+  ) => {
+    let topic0 = [sighash->EvmTypes.Hex.fromStringUnsafe]
+    switch eventFilters {
+    | None => [
+        {
+          Internal.topic0,
+          topic1: emptyTopics,
+          topic2: emptyTopics,
+          topic3: emptyTopics,
+        },
+      ]
+    | Some(eventFilters) => {
+        let eventFilters = if Js.typeof(eventFilters) === "function" {
+          (eventFilters->(Utils.magic: Js.Json.t => Internal.eventFiltersArgs => Js.Json.t))({
+            chainId: chain->ChainMap.Chain.toChainId,
+          })
+        } else {
+          eventFilters
+        }
+
+        switch eventFilters {
+        | Array([]) => [%raw(`{}`)]
+        | Array(a) => a
+        | _ => [eventFilters]
+        }->Js.Array2.map(eventFilter => {
+          switch eventFilter {
+          | Object(eventFilter) => {
+              Internal.topic0,
+              topic1: topic1(eventFilter),
+              topic2: topic2(eventFilter),
+              topic3: topic3(eventFilter),
+            }
+          | _ => Js.Exn.raiseError("Invalid event filters configuration. Expected an object")
+          }
+        })
+      }
+    }
+  }
+}

package/src/Utils.res

@@ -267,8 +267,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/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 = {