envio 2.26.0 → 2.27.0

package/evm.schema.json

@@ -106,6 +106,13 @@
         "boolean",
         "null"
       ]
+    },
+    "preload_handlers": {
+      "description": "Makes handlers run twice to enable preload optimisations. Removes handlerWithLoader API, since it's not needed. (recommended, default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
     }
   },
   "additionalProperties": false,
@@ -576,6 +583,15 @@
           "description": "A single address or a list of addresses to be indexed. This can be left as null in the case where this contracts addresses will be registered dynamically.",
           "$ref": "#/$defs/Addresses"
         },
+        "start_block": {
+          "description": "The block at which the indexer should start ingesting data for this specific contract. If not specified, uses the network start_block. Can be greater than the network start_block for more specific indexing.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        },
         "abi_file_path": {
           "description": "Relative path (from config) to a json abi. If this is used then each configured event should simply be referenced by its name",
           "type": [

package/fuel.schema.json

@@ -56,6 +56,13 @@
         "boolean",
         "null"
       ]
+    },
+    "preload_handlers": {
+      "description": "Makes handlers run twice to enable preload optimisations. Removes handlerWithLoader API, since it's not needed. (recommended, default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
     }
   },
   "additionalProperties": false,
@@ -217,6 +224,15 @@
           "description": "A single address or a list of addresses to be indexed. This can be left as null in the case where this contracts addresses will be registered dynamically.",
           "$ref": "#/$defs/Addresses"
         },
+        "start_block": {
+          "description": "The block at which the indexer should start ingesting data for this specific contract. If not specified, uses the network start_block. Can be greater than the network start_block for more specific indexing.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        },
         "abi_file_path": {
           "description": "Relative path (from config) to a json abi.",
           "type": "string"

package/index.d.ts

@@ -95,6 +95,7 @@ export function experimental_createEffect<
 // Important! Should match the index.js file
 export declare namespace S {
   export type Output<T> = Sury.Output<T>;
+  export type Infer<T> = Sury.Output<T>;
   export type Input<T> = Sury.Input<T>;
   export type Schema<Output, Input = unknown> = Sury.Schema<Output, Input>;
   export const string: typeof Sury.string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.26.0",
+  "version": "v2.27.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.26.0",
-    "envio-linux-arm64": "v2.26.0",
-    "envio-darwin-x64": "v2.26.0",
-    "envio-darwin-arm64": "v2.26.0"
+    "envio-linux-x64": "v2.27.0",
+    "envio-linux-arm64": "v2.27.0",
+    "envio-darwin-x64": "v2.27.0",
+    "envio-darwin-arm64": "v2.27.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.5",

package/src/EventRegister.res

@@ -0,0 +1,92 @@
+type t = {
+  contractName: string,
+  eventName: string,
+  mutable handler: option<Internal.handler>,
+  mutable contractRegister: option<Internal.contractRegister>,
+  mutable eventOptions: option<Internal.eventOptions<Js.Json.t>>,
+}
+
+let getHandler = (t: t) => t.handler
+
+let getContractRegister = (t: t) => t.contractRegister
+
+let getEventFilters = (t: t) => t.eventOptions->Belt.Option.flatMap(value => value.eventFilters)
+
+let isWildcard = (t: t) =>
+  t.eventOptions->Belt.Option.flatMap(value => value.wildcard)->Belt.Option.getWithDefault(false)
+
+let hasRegistration = ({handler, contractRegister}) =>
+  handler->Belt.Option.isSome || contractRegister->Belt.Option.isSome
+
+let make = (~contractName, ~eventName) => {
+  contractName,
+  eventName,
+  handler: None,
+  contractRegister: None,
+  eventOptions: None,
+}
+
+type eventNamespace = {contractName: string, eventName: string}
+exception DuplicateEventRegistration(eventNamespace)
+
+let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch eventOptions {
+  | Some(value) =>
+    let value =
+      value->(Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<Js.Json.t>)
+    switch t.eventOptions {
+    | None => t.eventOptions = Some(value)
+    | Some(existingValue) =>
+      if (
+        existingValue.wildcard !== value.wildcard ||
+          // TODO: Can improve the check by using deepEqual
+          existingValue.eventFilters !== value.eventFilters
+      ) {
+        let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+        DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+          ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+          ~msg="Duplicate eventOptions in handlers not allowed",
+        )
+      }
+    }
+  | None => ()
+  }
+}
+
+let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch t.handler {
+  | None =>
+    t.handler =
+      handler
+      ->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
+      ->Some
+  | Some(_) =>
+    let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+    DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+      ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+      ~msg="Duplicate registration of event handlers not allowed",
+    )
+  }
+
+  t->setEventOptions(~eventOptions, ~logger)
+}
+
+let setContractRegister = (t: t, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch t.contractRegister {
+  | None =>
+    t.contractRegister = Some(
+      contractRegister->(
+        Utils.magic: Internal.genericContractRegister<
+          Internal.genericContractRegisterArgs<'event, 'context>,
+        > => Internal.contractRegister
+      ),
+    )
+  | Some(_) =>
+    let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+    DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+      ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+      ~msg="Duplicate contractRegister handlers not allowed",
+    )
+  }
+  t->setEventOptions(~eventOptions, ~logger)
+}

package/src/EventRegister.res.js

@@ -0,0 +1,124 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Logging = require("./Logging.res.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+
+function getHandler(t) {
+  return t.handler;
+}
+
+function getContractRegister(t) {
+  return t.contractRegister;
+}
+
+function getEventFilters(t) {
+  return Belt_Option.flatMap(t.eventOptions, (function (value) {
+                return value.eventFilters;
+              }));
+}
+
+function isWildcard(t) {
+  return Belt_Option.getWithDefault(Belt_Option.flatMap(t.eventOptions, (function (value) {
+                    return value.wildcard;
+                  })), false);
+}
+
+function hasRegistration(param) {
+  var handler = param.handler;
+  var contractRegister = param.contractRegister;
+  if (Belt_Option.isSome(handler)) {
+    return true;
+  } else {
+    return Belt_Option.isSome(contractRegister);
+  }
+}
+
+function make(contractName, eventName) {
+  return {
+          contractName: contractName,
+          eventName: eventName,
+          handler: undefined,
+          contractRegister: undefined,
+          eventOptions: undefined
+        };
+}
+
+var DuplicateEventRegistration = /* @__PURE__ */Caml_exceptions.create("EventRegister.DuplicateEventRegistration");
+
+function setEventOptions(t, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  if (eventOptions === undefined) {
+    return ;
+  }
+  var existingValue = t.eventOptions;
+  if (existingValue === undefined) {
+    t.eventOptions = eventOptions;
+    return ;
+  }
+  if (!(existingValue.wildcard !== eventOptions.wildcard || existingValue.eventFilters !== eventOptions.eventFilters)) {
+    return ;
+  }
+  var eventNamespace_contractName = t.contractName;
+  var eventNamespace_eventName = t.eventName;
+  var eventNamespace = {
+    contractName: eventNamespace_contractName,
+    eventName: eventNamespace_eventName
+  };
+  ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate eventOptions in handlers not allowed", {
+        RE_EXN_ID: DuplicateEventRegistration,
+        _1: eventNamespace
+      });
+}
+
+function setHandler(t, handler, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  var match = t.handler;
+  if (match !== undefined) {
+    var eventNamespace_contractName = t.contractName;
+    var eventNamespace_eventName = t.eventName;
+    var eventNamespace = {
+      contractName: eventNamespace_contractName,
+      eventName: eventNamespace_eventName
+    };
+    ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate registration of event handlers not allowed", {
+          RE_EXN_ID: DuplicateEventRegistration,
+          _1: eventNamespace
+        });
+  } else {
+    t.handler = handler;
+  }
+  setEventOptions(t, eventOptions, logger);
+}
+
+function setContractRegister(t, contractRegister, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  var match = t.contractRegister;
+  if (match !== undefined) {
+    var eventNamespace_contractName = t.contractName;
+    var eventNamespace_eventName = t.eventName;
+    var eventNamespace = {
+      contractName: eventNamespace_contractName,
+      eventName: eventNamespace_eventName
+    };
+    ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate contractRegister handlers not allowed", {
+          RE_EXN_ID: DuplicateEventRegistration,
+          _1: eventNamespace
+        });
+  } else {
+    t.contractRegister = contractRegister;
+  }
+  setEventOptions(t, eventOptions, logger);
+}
+
+exports.make = make;
+exports.setHandler = setHandler;
+exports.setContractRegister = setContractRegister;
+exports.getHandler = getHandler;
+exports.getContractRegister = getContractRegister;
+exports.getEventFilters = getEventFilters;
+exports.isWildcard = isWildcard;
+exports.hasRegistration = hasRegistration;
+/* Logging Not a pure module */

package/src/EventRegister.resi

@@ -0,0 +1,21 @@
+type t
+let make: (~contractName: string, ~eventName: string) => t
+let setHandler: (
+  t,
+  Internal.genericHandler<
+    Internal.genericHandlerArgs<'event, Internal.handlerContext, 'loaderReturn>,
+  >,
+  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~logger: Pino.t=?,
+) => unit
+let setContractRegister: (
+  t,
+  Internal.genericContractRegister<Internal.genericContractRegisterArgs<'event, 'context>>,
+  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~logger: Pino.t=?,
+) => unit
+let getHandler: t => option<Internal.handler>
+let getContractRegister: t => option<Internal.contractRegister>
+let getEventFilters: t => option<Js.Json.t>
+let isWildcard: t => bool
+let hasRegistration: t => bool

package/src/FetchState.res

@@ -966,8 +966,7 @@ let make = (
   ~startBlock,
   ~endBlock,
   ~eventConfigs: array<Internal.eventConfig>,
-  ~staticContracts: dict<array<Address.t>>,
-  ~dynamicContracts: array<indexingContract>,
+  ~contracts: array<indexingContract>,
   ~maxAddrInPartition,
   ~chainId,
   ~blockLag=?,
@@ -1041,49 +1040,21 @@ let make = (
 
       let pendingNormalPartition = ref(makePendingNormalPartition())
 
-      let registerAddress = (contractName, address, ~dc: option<indexingContract>=?) => {
-        let pendingPartition = pendingNormalPartition.contents
-        switch pendingPartition.addressesByContractName->Utils.Dict.dangerouslyGetNonOption(
-          contractName,
-        ) {
-        | Some(addresses) => addresses->Array.push(address)
-        | None => pendingPartition.addressesByContractName->Js.Dict.set(contractName, [address])
-        }
-        indexingContracts->Js.Dict.set(
-          address->Address.toString,
-          switch dc {
-          | Some(dc) => dc
-          | None => {
-              address,
-              contractName,
-              startBlock,
-              register: Config,
-            }
-          },
-        )
-        if (
-          pendingPartition.addressesByContractName->addressesByContractNameCount ===
-            maxAddrInPartition
-        ) {
-          partitions->Array.push(pendingPartition)
-          pendingNormalPartition := makePendingNormalPartition()
-        }
-      }
-
-      staticContracts
-      ->Js.Dict.entries
-      ->Array.forEach(((contractName, addresses)) => {
-        if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          addresses->Array.forEach(a => {
-            registerAddress(contractName, a)
-          })
-        }
-      })
-
-      dynamicContracts->Array.forEach(dc => {
-        let contractName = dc.contractName
+      contracts->Array.forEach(contract => {
+        let contractName = contract.contractName
         if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          registerAddress(contractName, dc.address, ~dc)
+          let pendingPartition = pendingNormalPartition.contents
+          pendingPartition.addressesByContractName->Utils.Dict.push(contractName, contract.address)
+          indexingContracts->Js.Dict.set(contract.address->Address.toString, contract)
+          if (
+            pendingPartition.addressesByContractName->addressesByContractNameCount ===
+              maxAddrInPartition
+          ) {
+            // FIXME: should split into separate partitions
+            // depending on the start block
+            partitions->Array.push(pendingPartition)
+            pendingNormalPartition := makePendingNormalPartition()
+          }
         }
       })
 

package/src/FetchState.res.js

@@ -698,7 +698,7 @@ function getEarliestEvent(param) {
   }
 }
 
-function make(startBlock, endBlock, eventConfigs, staticContracts, dynamicContracts, maxAddrInPartition, chainId, blockLag) {
+function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, blockLag) {
   var latestFetchedBlock_blockNumber = startBlock - 1 | 0;
   var latestFetchedBlock = {
     blockNumber: latestFetchedBlock_blockNumber,
@@ -761,40 +761,18 @@ function make(startBlock, endBlock, eventConfigs, staticContracts, dynamicContra
     var pendingNormalPartition = {
       contents: makePendingNormalPartition()
     };
-    var registerAddress = function (contractName, address, dc) {
-      var pendingPartition = pendingNormalPartition.contents;
-      var addresses = pendingPartition.addressesByContractName[contractName];
-      if (addresses !== undefined) {
-        addresses.push(address);
-      } else {
-        pendingPartition.addressesByContractName[contractName] = [address];
-      }
-      indexingContracts[address] = dc !== undefined ? dc : ({
-            address: address,
-            contractName: contractName,
-            startBlock: startBlock,
-            register: "Config"
-          });
-      if (addressesByContractNameCount(pendingPartition.addressesByContractName) === maxAddrInPartition) {
-        partitions.push(pendingPartition);
-        pendingNormalPartition.contents = makePendingNormalPartition();
-        return ;
-      }
-      
-    };
-    Belt_Array.forEach(Js_dict.entries(staticContracts), (function (param) {
-            var contractName = param[0];
-            if (contractNamesWithNormalEvents.has(contractName)) {
-              return Belt_Array.forEach(param[1], (function (a) {
-                            registerAddress(contractName, a, undefined);
-                          }));
+    Belt_Array.forEach(contracts, (function (contract) {
+            var contractName = contract.contractName;
+            if (!contractNamesWithNormalEvents.has(contractName)) {
+              return ;
             }
-            
-          }));
-    Belt_Array.forEach(dynamicContracts, (function (dc) {
-            var contractName = dc.contractName;
-            if (contractNamesWithNormalEvents.has(contractName)) {
-              return registerAddress(contractName, dc.address, dc);
+            var pendingPartition = pendingNormalPartition.contents;
+            Utils.Dict.push(pendingPartition.addressesByContractName, contractName, contract.address);
+            indexingContracts[contract.address] = contract;
+            if (addressesByContractNameCount(pendingPartition.addressesByContractName) === maxAddrInPartition) {
+              partitions.push(pendingPartition);
+              pendingNormalPartition.contents = makePendingNormalPartition();
+              return ;
             }
             
           }));

package/src/Internal.gen.ts

@@ -34,6 +34,14 @@ export type genericHandlerArgs<event,context,loaderReturn> = {
 
 export type genericHandler<args> = (_1:args) => Promise<void>;
 
+export type entityHandlerContext<entity> = {
+  readonly get: (_1:string) => Promise<(undefined | entity)>; 
+  readonly getOrThrow: (_1:string, message:(undefined | string)) => Promise<entity>; 
+  readonly getOrCreate: (_1:entity) => Promise<entity>; 
+  readonly set: (_1:entity) => void; 
+  readonly deleteUnsafe: (_1:string) => void
+};
+
 export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly loader: loader; 
   readonly handler: handler; 
@@ -43,6 +51,13 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly preRegisterDynamicContracts?: boolean
 };
 
+export type eventOptions<eventFilters> = {
+  readonly wildcard?: boolean; 
+  readonly eventFilters?: eventFilters; 
+  /** @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration. */
+  readonly preRegisterDynamicContracts?: boolean
+};
+
 export type fuelSupplyParams = { readonly subId: string; readonly amount: bigint };
 
 export type fuelTransferParams = {

package/src/Internal.res

@@ -16,8 +16,6 @@ type event = genericEvent<eventParams, eventBlock, eventTransaction>
 
 external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
 
-type loaderReturn
-
 @genType
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
@@ -26,10 +24,6 @@ type genericLoaderArgs<'event, 'context> = {
 @genType
 type genericLoader<'args, 'loaderReturn> = 'args => promise<'loaderReturn>
 
-type loaderContext
-type loaderArgs = genericLoaderArgs<event, loaderContext>
-type loader = genericLoader<loaderArgs, loaderReturn>
-
 @genType
 type genericContractRegisterArgs<'event, 'context> = {
   event: 'event,
@@ -51,8 +45,21 @@ type genericHandlerArgs<'event, 'context, 'loaderReturn> = {
 @genType
 type genericHandler<'args> = 'args => promise<unit>
 
-type handlerContext
-type handlerArgs = genericHandlerArgs<event, handlerContext, loaderReturn>
+@genType
+type entityHandlerContext<'entity> = {
+  get: string => promise<option<'entity>>,
+  getOrThrow: (string, ~message: string=?) => promise<'entity>,
+  getOrCreate: 'entity => promise<'entity>,
+  set: 'entity => unit,
+  deleteUnsafe: string => unit,
+}
+
+type loaderReturn
+type handlerContext = private {isPreload: bool}
+type handlerArgs = {
+  event: event,
+  context: handlerContext,
+}
 type handler = genericHandler<handlerArgs>
 
 @genType
@@ -81,7 +88,6 @@ type eventConfig = private {
   // Usually always false for wildcard events
   // But might be true for wildcard event with dynamic event filter by addresses
   dependsOnAddresses: bool,
-  loader: option<loader>,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
@@ -138,6 +144,16 @@ type eventItem = {
   mutable loggerCache?: Pino.t,
 }
 
+@genType
+type eventOptions<'eventFilters> = {
+  wildcard?: bool,
+  eventFilters?: 'eventFilters,
+  /**
+    @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration.
+  */
+  preRegisterDynamicContracts?: bool,
+}
+
 @genType
 type fuelSupplyParams = {
   subId: string,
@@ -214,7 +230,7 @@ let makeCacheTable = (~effectName) => {
     cacheTablePrefix ++ effectName,
     ~fields=[
       Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false)),
+      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false), ~isNullable=true),
     ],
     ~compositeIndices=[],
   )

package/src/Internal.res.js

@@ -40,7 +40,7 @@ var cacheTablePrefix = "envio_effect_";
 function makeCacheTable(effectName) {
   return Table.mkTable(cacheTablePrefix + effectName, [], [
               Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
+              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, true, undefined, undefined, undefined)
             ]);
 }
 

package/src/Logging.res

@@ -155,6 +155,7 @@ let getEventLogger = (eventItem: Internal.eventItem) => {
           "chainId": eventItem.chain->ChainMap.Chain.toChainId,
           "block": eventItem.blockNumber,
           "logIndex": eventItem.logIndex,
+          "address": eventItem.event.srcAddress,
         }->createChildParams,
       )
       eventItem.loggerCache = Some(l)

package/src/Logging.res.js

@@ -187,7 +187,8 @@ function getEventLogger(eventItem) {
             eventName: eventItem.eventConfig.name,
             chainId: eventItem.chain,
             block: eventItem.blockNumber,
-            logIndex: eventItem.logIndex
+            logIndex: eventItem.logIndex,
+            address: eventItem.event.srcAddress
           }));
   eventItem.loggerCache = l$1;
   return l$1;

package/src/bindings/Promise.res

@@ -53,6 +53,8 @@ external race: array<t<'a>> => t<'a> = "race"
 
 external done: promise<'a> => unit = "%ignore"
 
+external ignoreValue: promise<'a> => promise<unit> = "%identity"
+
 external unsafe_async: 'a => promise<'a> = "%identity"
 external unsafe_await: promise<'a> => 'a = "?await"