envio 2.29.0-alpha.0 → 2.29.0-alpha.2

package/index.d.ts

@@ -4,6 +4,9 @@ export type {
   effectContext as EffectContext,
   effectArgs as EffectArgs,
   effectOptions as EffectOptions,
+  blockEvent as BlockEvent,
+  onBlockArgs as OnBlockArgs,
+  onBlockOptions as OnBlockOptions,
 } from "./src/Envio.gen.ts";
 export type { EffectCaller } from "./src/Types.ts";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.29.0-alpha.0",
+  "version": "v2.29.0-alpha.2",
   "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.29.0-alpha.0",
-    "envio-linux-arm64": "v2.29.0-alpha.0",
-    "envio-darwin-x64": "v2.29.0-alpha.0",
-    "envio-darwin-arm64": "v2.29.0-alpha.0"
+    "envio-linux-x64": "v2.29.0-alpha.2",
+    "envio-linux-arm64": "v2.29.0-alpha.2",
+    "envio-darwin-x64": "v2.29.0-alpha.2",
+    "envio-darwin-arm64": "v2.29.0-alpha.2"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",

package/src/Batch.res

@@ -7,7 +7,7 @@ type progressedChain = {
 }
 
 type t = {
-  items: array<Internal.eventItem>,
+  items: array<Internal.item>,
   progressedChains: array<progressedChain>,
   fetchStates: ChainMap.t<FetchState.t>,
   dcsToStoreByChainId: dict<array<FetchState.indexingContract>>,
@@ -18,19 +18,9 @@ type multiChainEventComparitor = {
   earliestEvent: FetchState.queueItem,
 }
 
-let getComparitorFromItem = (queueItem: Internal.eventItem) => {
-  let {timestamp, chain, blockNumber, logIndex} = queueItem
-  EventUtils.getEventComparator({
-    timestamp,
-    chainId: chain->ChainMap.Chain.toChainId,
-    blockNumber,
-    logIndex,
-  })
-}
-
 let getQueueItemComparitor = (earliestQueueItem: FetchState.queueItem, ~chain) => {
   switch earliestQueueItem {
-  | Item({item}) => item->getComparitorFromItem
+  | Item({item}) => item->EventUtils.getOrderedBatchItemComparator
   | NoItem({latestFetchedBlock: {blockTimestamp, blockNumber}}) => (
       blockTimestamp,
       chain->ChainMap.Chain.toChainId,
@@ -78,13 +68,13 @@ let popOrderedBatchItems = (
   let rec loop = () =>
     if items->Array.length < maxBatchSize {
       switch fetchStates->getOrderedNextItem {
-      | Some({earliestEvent}) =>
+      | Some({earliestEvent, chain}) =>
         switch earliestEvent {
         | NoItem(_) => ()
         | Item({item, popItemOffQueue}) => {
             popItemOffQueue()
             items->Js.Array2.push(item)->ignore
-            sizePerChain->Utils.Dict.incrementByInt(item.chain->ChainMap.Chain.toChainId)
+            sizePerChain->Utils.Dict.incrementByInt(chain->ChainMap.Chain.toChainId)
             loop()
           }
         }

package/src/Batch.res.js

@@ -8,18 +8,9 @@ var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var EventUtils = require("./EventUtils.res.js");
 var FetchState = require("./FetchState.res.js");
 
-function getComparitorFromItem(queueItem) {
-  return EventUtils.getEventComparator({
-              timestamp: queueItem.timestamp,
-              chainId: queueItem.chain,
-              blockNumber: queueItem.blockNumber,
-              logIndex: queueItem.logIndex
-            });
-}
-
 function getQueueItemComparitor(earliestQueueItem, chain) {
   if (earliestQueueItem.TAG === "Item") {
-    return getComparitorFromItem(earliestQueueItem._0.item);
+    return EventUtils.getOrderedBatchItemComparator(earliestQueueItem._0.item);
   }
   var match = earliestQueueItem.latestFetchedBlock;
   return [
@@ -70,10 +61,9 @@ function popOrderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
         return ;
       }
       var match$1 = earliestEvent._0;
-      var item = match$1.item;
       match$1.popItemOffQueue();
-      items.push(item);
-      Utils.Dict.incrementByInt(sizePerChain, item.chain);
+      items.push(match$1.item);
+      Utils.Dict.incrementByInt(sizePerChain, match.chain);
       continue ;
     };
   };
@@ -120,7 +110,6 @@ function popUnorderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
   return items;
 }
 
-exports.getComparitorFromItem = getComparitorFromItem;
 exports.getQueueItemComparitor = getQueueItemComparitor;
 exports.isQueueItemEarlier = isQueueItemEarlier;
 exports.getOrderedNextItem = getOrderedNextItem;

package/src/Envio.gen.ts

@@ -11,6 +11,20 @@ import type {Logger as $$logger} from './Types.ts';
 
 import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen';
 
+import type {blockEvent as Internal_blockEvent} from './Internal.gen';
+
+export type blockEvent = Internal_blockEvent;
+
+export type onBlockArgs<context> = { readonly block: blockEvent; readonly context: context };
+
+export type onBlockOptions<chain> = {
+  readonly name: string; 
+  readonly chain: chain; 
+  readonly interval?: number; 
+  readonly startBlock?: number; 
+  readonly endBlock?: number
+};
+
 export type logger = $$logger;
 
 export type effect<input,output> = $$effect<input,output>;

package/src/Envio.res

@@ -2,6 +2,24 @@
 // Should be an entry point after we get rid of the generated project.
 // Don't forget to keep index.d.ts in sync with this file.
 
+@genType
+type blockEvent = Internal.blockEvent
+
+@genType
+type onBlockArgs<'context> = {
+  block: blockEvent,
+  context: 'context,
+}
+
+@genType
+type onBlockOptions<'chain> = {
+  name: string,
+  chain: 'chain,
+  interval?: int,
+  startBlock?: int,
+  endBlock?: int,
+}
+
 @genType.import(("./Types.ts", "Logger"))
 type logger = {
   debug: 'params. (string, ~params: {..} as 'params=?) => unit,

package/src/EventRegister.res

@@ -1,3 +1,141 @@
+type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+
+type activeRegistration = {
+  ecosystem: InternalConfig.ecosystem,
+  multichain: InternalConfig.multichain,
+  preloadHandlers: bool,
+  registrations: registrations,
+  mutable finished: bool,
+}
+
+let activeRegistration = ref(None)
+
+// Might happen for tests when the handler file
+// is imported by a non-envio process (eg mocha)
+// and initialized before we started registration.
+// So we track them here to register when the startRegistration is called.
+// Theoretically we could keep preRegistration without an explicit start
+// but I want it to be this way, so for the actual indexer run
+// an error is thrown with the exact stack trace where the handler was registered.
+let preRegistered = []
+
+let withRegistration = (fn: activeRegistration => unit) => {
+  switch activeRegistration.contents {
+  | None => preRegistered->Belt.Array.push(fn)
+  | Some(r) =>
+    if r.finished {
+      Js.Exn.raiseError(
+        "The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.",
+      )
+    } else {
+      fn(r)
+    }
+  }
+}
+
+let startRegistration = (~ecosystem, ~multichain, ~preloadHandlers) => {
+  let r = {
+    ecosystem,
+    multichain,
+    preloadHandlers,
+    registrations: {
+      onBlockByChainId: Js.Dict.empty(),
+    },
+    finished: false,
+  }
+  activeRegistration.contents = Some(r)
+  while preRegistered->Js.Array2.length > 0 {
+    // Loop + cleanup in one go
+    switch preRegistered->Js.Array2.pop {
+    | Some(fn) => fn(r)
+    | None => ()
+    }
+  }
+}
+
+let finishRegistration = () => {
+  switch activeRegistration.contents {
+  | Some(r) => {
+      r.finished = true
+      r.registrations
+    }
+  | None =>
+    Js.Exn.raiseError("The indexer has not started registering handlers, so can't finish it.")
+  }
+}
+
+let onBlockOptionsSchema = S.schema(s =>
+  {
+    "name": s.matches(S.string),
+    "chain": s.matches(S.int),
+    "interval": s.matches(S.option(S.int->S.intMin(1))->S.Option.getOr(1)),
+    "startBlock": s.matches(S.option(S.int)),
+    "endBlock": s.matches(S.option(S.int)),
+  }
+)
+
+let onBlock = (rawOptions: unknown, handler: Internal.onBlockArgs => promise<unit>) => {
+  withRegistration(registration => {
+    // There's no big reason for this. It's just more work
+    switch registration.ecosystem {
+    | Evm => ()
+    | Fuel =>
+      Js.Exn.raiseError(
+        "Block Handlers are not supported for non-EVM ecosystems. Please reach out to the Envio team if you need this feature.",
+      )
+    }
+    // We need to get timestamp for ordered multichain mode
+    switch registration.multichain {
+    | Unordered => ()
+    | Ordered =>
+      Js.Exn.raiseError(
+        "Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature or enable unordered multichain mode with `unordered_multichain_mode: true` in your config.",
+      )
+    }
+    // So we encourage users to upgrade to preload optimization
+    // otherwise block handlers will be extremely slow
+    switch registration.preloadHandlers {
+    | true => ()
+    | false =>
+      Js.Exn.raiseError(
+        "Block Handlers require the Preload Optimization feature. Enable it by setting the `preload_handlers` option to `true` in your config.",
+      )
+    }
+
+    let options = rawOptions->S.parseOrThrow(onBlockOptionsSchema)
+    let chainId = switch options["chain"] {
+    | chainId => chainId
+    // Dmitry: I want to add names for chains in the future
+    // and to be able to use them as a lookup.
+    // To do so, we'll need to pass a config during reigstration
+    // instead of isInitialized check.
+    }
+
+    let onBlockByChainId = registration.registrations.onBlockByChainId
+
+    switch onBlockByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->Belt.Int.toString) {
+    | None =>
+      onBlockByChainId->Utils.Dict.setByInt(
+        chainId,
+        [
+          (
+            {
+              index: 0,
+              name: options["name"],
+              startBlock: options["startBlock"],
+              endBlock: options["endBlock"],
+              interval: options["interval"],
+              chainId,
+              handler,
+            }: Internal.onBlockConfig
+          ),
+        ],
+      )
+    | Some(_) => Js.Exn.raiseError("Currently only one onBlock handler per chain is supported")
+    }
+  })
+}
+
 type t = {
   contractName: string,
   eventName: string,
@@ -54,39 +192,43 @@ let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
 }
 
 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",
-    )
-  }
+  withRegistration(_ => {
+    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)
+    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)
+  withRegistration(_ => {
+    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

@@ -1,10 +1,108 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Js_exn = require("rescript/lib/js/js_exn.js");
 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");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+
+var activeRegistration = {
+  contents: undefined
+};
+
+var preRegistered = [];
+
+function withRegistration(fn) {
+  var r = activeRegistration.contents;
+  if (r !== undefined) {
+    if (r.finished) {
+      return Js_exn.raiseError("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
+    } else {
+      return fn(r);
+    }
+  } else {
+    preRegistered.push(fn);
+    return ;
+  }
+}
+
+function startRegistration(ecosystem, multichain, preloadHandlers) {
+  var r = {
+    ecosystem: ecosystem,
+    multichain: multichain,
+    preloadHandlers: preloadHandlers,
+    registrations: {
+      onBlockByChainId: {}
+    },
+    finished: false
+  };
+  activeRegistration.contents = r;
+  while(preRegistered.length > 0) {
+    var fn = preRegistered.pop();
+    if (fn !== undefined) {
+      fn(r);
+    }
+    
+  };
+}
+
+function finishRegistration() {
+  var r = activeRegistration.contents;
+  if (r !== undefined) {
+    r.finished = true;
+    return r.registrations;
+  } else {
+    return Js_exn.raiseError("The indexer has not started registering handlers, so can't finish it.");
+  }
+}
+
+var onBlockOptionsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              name: s.m(S$RescriptSchema.string),
+              chain: s.m(S$RescriptSchema.$$int),
+              interval: s.m(S$RescriptSchema.$$Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.$$int, 1, undefined)), 1)),
+              startBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
+            };
+    });
+
+function onBlock(rawOptions, handler) {
+  withRegistration(function (registration) {
+        var match = registration.ecosystem;
+        if (match !== "evm") {
+          Js_exn.raiseError("Block Handlers are not supported for non-EVM ecosystems. Please reach out to the Envio team if you need this feature.");
+        }
+        var match$1 = registration.multichain;
+        if (match$1 === "ordered") {
+          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature or enable unordered multichain mode with `unordered_multichain_mode: true` in your config.");
+        }
+        if (registration.preloadHandlers) {
+          
+        } else {
+          Js_exn.raiseError("Block Handlers require the Preload Optimization feature. Enable it by setting the `preload_handlers` option to `true` in your config.");
+        }
+        var options = S$RescriptSchema.parseOrThrow(rawOptions, onBlockOptionsSchema);
+        var chainId = options.chain;
+        var onBlockByChainId = registration.registrations.onBlockByChainId;
+        var match$2 = onBlockByChainId[String(chainId)];
+        if (match$2 !== undefined) {
+          return Js_exn.raiseError("Currently only one onBlock handler per chain is supported");
+        } else {
+          onBlockByChainId[chainId] = [{
+              index: 0,
+              name: options.name,
+              chainId: chainId,
+              startBlock: options.startBlock,
+              endBlock: options.endBlock,
+              interval: options.interval,
+              handler: handler
+            }];
+          return ;
+        }
+      });
+}
 
 function getHandler(t) {
   return t.handler;
@@ -75,44 +173,50 @@ function setEventOptions(t, eventOptions, loggerOpt) {
 
 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);
+  withRegistration(function (param) {
+        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);
+  withRegistration(function (param) {
+        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.startRegistration = startRegistration;
+exports.finishRegistration = finishRegistration;
 exports.make = make;
 exports.setHandler = setHandler;
 exports.setContractRegister = setContractRegister;
@@ -121,4 +225,5 @@ exports.getContractRegister = getContractRegister;
 exports.getEventFilters = getEventFilters;
 exports.isWildcard = isWildcard;
 exports.hasRegistration = hasRegistration;
-/* Logging Not a pure module */
+exports.onBlock = onBlock;
+/* onBlockOptionsSchema Not a pure module */

package/src/EventRegister.resi

@@ -1,3 +1,12 @@
+type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+
+let startRegistration: (
+  ~ecosystem: InternalConfig.ecosystem,
+  ~multichain: InternalConfig.multichain,
+  ~preloadHandlers: bool,
+) => unit
+let finishRegistration: unit => registrations
+
 type t
 let make: (~contractName: string, ~eventName: string) => t
 let setHandler: (
@@ -19,3 +28,5 @@ let getContractRegister: t => option<Internal.contractRegister>
 let getEventFilters: t => option<Js.Json.t>
 let isWildcard: t => bool
 let hasRegistration: t => bool
+
+let onBlock: (unknown, Internal.onBlockArgs => promise<unit>) => unit