envio 2.15.0 → 2.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.15.0",
+  "version": "v2.16.1",
   "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.15.0",
-    "envio-linux-arm64": "v2.15.0",
-    "envio-darwin-x64": "v2.15.0",
-    "envio-darwin-arm64": "v2.15.0"
+    "envio-linux-x64": "v2.16.1",
+    "envio-linux-arm64": "v2.16.1",
+    "envio-darwin-x64": "v2.16.1",
+    "envio-darwin-arm64": "v2.16.1"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",

package/src/Internal.res

@@ -64,11 +64,18 @@ type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
   preRegisterDynamicContracts?: bool,
 }
 
-type baseEventConfig = {
+// 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>,
@@ -83,7 +90,7 @@ type fuelEventKind =
   | Transfer
   | Call
 type fuelEventConfig = {
-  ...baseEventConfig,
+  ...eventConfig,
   kind: fuelEventKind,
 }
 type fuelContractConfig = {
@@ -98,21 +105,26 @@ type topicSelection = {
   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 = {
-  ...baseEventConfig,
-  getTopicSelectionsOrThrow: (~chain: ChainMap.Chain.t) => array<topicSelection>,
+  ...eventConfig,
+  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
   blockSchema: S.schema<eventBlock>,
   transactionSchema: S.schema<eventTransaction>,
   convertHyperSyncEventArgs: HyperSyncClient.Decoder.decodedEvent => eventParams,
 }
 type evmContractConfig = {
   name: string,
-  abi: Ethers.abi,
+  abi: EvmTypes.Abi.t,
   events: array<evmEventConfig>,
 }
 
 type eventItem = {
-  eventConfig: baseEventConfig,
+  eventConfig: eventConfig,
   timestamp: int,
   chain: ChainMap.Chain.t,
   blockNumber: int,
@@ -149,5 +161,3 @@ type entity = private {id: string}
 
 @genType.import(("./bindings/OpaqueTypes.ts", "invalid"))
 type noEventFilters
-type eventFilters
-type eventFiltersArgs = {chainId: int}

package/src/LogSelection.res

@@ -57,53 +57,123 @@ let make = (~addresses, ~topicSelections) => {
   {addresses, topicSelections}
 }
 
-let fromEventFiltersOrThrow = {
+type parsedEventFilters = {
+  getEventFiltersOrThrow: ChainMap.Chain.t => Internal.eventFilters,
+  dependsOnAddresses: bool,
+}
+
+let parseEventFiltersOrThrow = {
   let emptyTopics = []
   let noopGetter = _ => emptyTopics
 
   (
-    ~chain,
     ~eventFilters: option<Js.Json.t>,
     ~sighash,
+    ~params,
     ~topic1=noopGetter,
     ~topic2=noopGetter,
     ~topic3=noopGetter,
-  ) => {
+  ): parsedEventFilters => {
+    let dependsOnAddresses = ref(false)
     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
-        }
+    let default = {
+      Internal.topic0,
+      topic1: emptyTopics,
+      topic2: emptyTopics,
+      topic3: emptyTopics,
+    }
 
-        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),
+    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")
           }
-        })
+        | _ => 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) => {

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,