envio 2.29.0-alpha.1 → 2.29.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.29.0-alpha.1",
+  "version": "v2.29.0-alpha.3",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,19 +25,21 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.29.0-alpha.1",
-    "envio-linux-arm64": "v2.29.0-alpha.1",
-    "envio-darwin-x64": "v2.29.0-alpha.1",
-    "envio-darwin-arm64": "v2.29.0-alpha.1"
+    "envio-linux-x64": "v2.29.0-alpha.3",
+    "envio-linux-arm64": "v2.29.0-alpha.3",
+    "envio-darwin-x64": "v2.29.0-alpha.3",
+    "envio-darwin-arm64": "v2.29.0-alpha.3"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",
+    "@envio-dev/hyperfuel-client": "1.2.2",
     "rescript": "11.1.3",
     "rescript-schema": "9.3.0",
     "viem": "2.21.0",
     "bignumber.js": "9.1.2",
     "pino": "8.16.1",
     "pino-pretty": "10.2.3",
+    "@elastic/ecs-pino-format": "1.4.0",
     "prom-client": "15.0.0"
   },
   "files": [

package/src/Batch.res

@@ -58,6 +58,18 @@ let getOrderedNextItem = (fetchStates: ChainMap.t<FetchState.t>): option<
   })
 }
 
+let hasUnorderedNextItem = (fetchStates: ChainMap.t<FetchState.t>) => {
+  fetchStates
+  ->ChainMap.values
+  ->Js.Array2.some(fetchState => {
+    fetchState->FetchState.isActivelyIndexing &&
+      switch fetchState->FetchState.getEarliestEvent {
+      | Item(_) => true
+      | NoItem(_) => false
+      }
+  })
+}
+
 let popOrderedBatchItems = (
   ~maxBatchSize,
   ~fetchStates: ChainMap.t<FetchState.t>,

package/src/Batch.res.js

@@ -45,6 +45,20 @@ function getOrderedNextItem(fetchStates) {
               }));
 }
 
+function hasUnorderedNextItem(fetchStates) {
+  return ChainMap.values(fetchStates).some(function (fetchState) {
+              if (!FetchState.isActivelyIndexing(fetchState)) {
+                return false;
+              }
+              var match = FetchState.getEarliestEvent(fetchState);
+              if (match.TAG === "Item") {
+                return true;
+              } else {
+                return false;
+              }
+            });
+}
+
 function popOrderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
   var items = [];
   var loop = function () {
@@ -113,6 +127,7 @@ function popUnorderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
 exports.getQueueItemComparitor = getQueueItemComparitor;
 exports.isQueueItemEarlier = isQueueItemEarlier;
 exports.getOrderedNextItem = getOrderedNextItem;
+exports.hasUnorderedNextItem = hasUnorderedNextItem;
 exports.popOrderedBatchItems = popOrderedBatchItems;
 exports.popUnorderedBatchItems = popUnorderedBatchItems;
 /* Utils Not a pure module */

package/src/Envio.gen.ts

@@ -17,9 +17,13 @@ export type blockEvent = Internal_blockEvent;
 
 export type onBlockArgs<context> = { readonly block: blockEvent; readonly context: context };
 
-export type chainReference = number;
-
-export type onBlockOptions = { readonly name: string; readonly chain: chainReference };
+export type onBlockOptions<chain> = {
+  readonly name: string; 
+  readonly chain: chain; 
+  readonly interval?: number; 
+  readonly startBlock?: number; 
+  readonly endBlock?: number
+};
 
 export type logger = $$logger;
 

package/src/Envio.res

@@ -11,16 +11,13 @@ type onBlockArgs<'context> = {
   context: 'context,
 }
 
-@unboxed
-type chainReference = Id(int) // | Name(string)
-
 @genType
-type onBlockOptions = {
+type onBlockOptions<'chain> = {
   name: string,
-  chain: chainReference,
-  // interval?: int,
-  // startBlock?: int,
-  // endBlock?: int,
+  chain: 'chain,
+  interval?: int,
+  startBlock?: int,
+  endBlock?: int,
 }
 
 @genType.import(("./Types.ts", "Logger"))

package/src/EventRegister.res

@@ -10,11 +10,18 @@ type activeRegistration = {
 
 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 => // The file with handlers might run by a non-envio process (eg mocha)
-    // So we just ignore handlers in this case
-    ()
+  | None => preRegistered->Belt.Array.push(fn)
   | Some(r) =>
     if r.finished {
       Js.Exn.raiseError(
@@ -27,7 +34,7 @@ let withRegistration = (fn: activeRegistration => unit) => {
 }
 
 let startRegistration = (~ecosystem, ~multichain, ~preloadHandlers) => {
-  activeRegistration.contents = Some({
+  let r = {
     ecosystem,
     multichain,
     preloadHandlers,
@@ -35,7 +42,15 @@ let startRegistration = (~ecosystem, ~multichain, ~preloadHandlers) => {
       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 = () => {
@@ -49,12 +64,17 @@ let finishRegistration = () => {
   }
 }
 
-let onBlockOptionsSchema = S.schema((s): Envio.onBlockOptions => {
-  name: s.matches(S.string),
-  chain: Id(s.matches(S.int)),
-})
+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 = (options: Envio.onBlockOptions, handler: Internal.onBlockArgs => promise<unit>) => {
+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 {
@@ -82,9 +102,9 @@ let onBlock = (options: Envio.onBlockOptions, handler: Internal.onBlockArgs => p
       )
     }
 
-    options->S.assertOrThrow(onBlockOptionsSchema)
-    let chainId = switch options.chain {
-    | Id(chainId) => chainId
+    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
@@ -101,14 +121,30 @@ let onBlock = (options: Envio.onBlockOptions, handler: Internal.onBlockArgs => p
           (
             {
               index: 0,
-              name: options.name,
+              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")
+    | Some(onBlockConfigs) =>
+      onBlockConfigs->Belt.Array.push(
+        (
+          {
+            index: onBlockConfigs->Belt.Array.length,
+            name: options["name"],
+            startBlock: options["startBlock"],
+            endBlock: options["endBlock"],
+            interval: options["interval"],
+            chainId,
+            handler,
+          }: Internal.onBlockConfig
+        ),
+      )
     }
   })
 }

package/src/EventRegister.res.js

@@ -12,6 +12,8 @@ var activeRegistration = {
   contents: undefined
 };
 
+var preRegistered = [];
+
 function withRegistration(fn) {
   var r = activeRegistration.contents;
   if (r !== undefined) {
@@ -20,12 +22,14 @@ function withRegistration(fn) {
     } else {
       return fn(r);
     }
+  } else {
+    preRegistered.push(fn);
+    return ;
   }
-  
 }
 
 function startRegistration(ecosystem, multichain, preloadHandlers) {
-  activeRegistration.contents = {
+  var r = {
     ecosystem: ecosystem,
     multichain: multichain,
     preloadHandlers: preloadHandlers,
@@ -34,6 +38,14 @@ function startRegistration(ecosystem, multichain, preloadHandlers) {
     },
     finished: false
   };
+  activeRegistration.contents = r;
+  while(preRegistered.length > 0) {
+    var fn = preRegistered.pop();
+    if (fn !== undefined) {
+      fn(r);
+    }
+    
+  };
 }
 
 function finishRegistration() {
@@ -49,11 +61,14 @@ function finishRegistration() {
 var onBlockOptionsSchema = S$RescriptSchema.schema(function (s) {
       return {
               name: s.m(S$RescriptSchema.string),
-              chain: s.m(S$RescriptSchema.$$int)
+              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(options, handler) {
+function onBlock(rawOptions, handler) {
   withRegistration(function (registration) {
         var match = registration.ecosystem;
         if (match !== "evm") {
@@ -68,20 +83,30 @@ function onBlock(options, handler) {
         } else {
           Js_exn.raiseError("Block Handlers require the Preload Optimization feature. Enable it by setting the `preload_handlers` option to `true` in your config.");
         }
-        S$RescriptSchema.assertOrThrow(options, onBlockOptionsSchema);
+        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");
+        var onBlockConfigs = onBlockByChainId[String(chainId)];
+        if (onBlockConfigs !== undefined) {
+          onBlockConfigs.push({
+                index: onBlockConfigs.length,
+                name: options.name,
+                chainId: chainId,
+                startBlock: options.startBlock,
+                endBlock: options.endBlock,
+                interval: options.interval,
+                handler: handler
+              });
         } else {
           onBlockByChainId[chainId] = [{
               index: 0,
               name: options.name,
               chainId: chainId,
+              startBlock: options.startBlock,
+              endBlock: options.endBlock,
+              interval: options.interval,
               handler: handler
             }];
-          return ;
         }
       });
 }

package/src/EventRegister.resi

@@ -29,4 +29,4 @@ let getEventFilters: t => option<Js.Json.t>
 let isWildcard: t => bool
 let hasRegistration: t => bool
 
-let onBlock: (Envio.onBlockOptions, Internal.onBlockArgs => promise<unit>) => unit
+let onBlock: (unknown, Internal.onBlockArgs => promise<unit>) => unit

package/src/EventUtils.res

@@ -16,6 +16,10 @@ let isEarlier = (item1: (int, int, int, int), item2: (int, int, int, int)) => {
   item1 < item2
 }
 
+let isEarlierUnordered = (item1: (int, int, int), item2: (int, int, int)) => {
+  item1 < item2
+}
+
 // type eventIndex = {
 //   blockNumber: int,
 //   logIndex: int,

package/src/EventUtils.res.js

@@ -20,6 +20,8 @@ function getOrderedBatchItemComparator(item) {
 
 var isEarlier = Caml_obj.lessthan;
 
+var isEarlierUnordered = Caml_obj.lessthan;
+
 function packEventIndex(blockNumber, logIndex) {
   var blockNumber$1 = BigInt(blockNumber);
   var logIndex$1 = BigInt(logIndex);
@@ -34,6 +36,7 @@ function getEventIdKeyString(chainId, eventId) {
 
 exports.getOrderedBatchItemComparator = getOrderedBatchItemComparator;
 exports.isEarlier = isEarlier;
+exports.isEarlierUnordered = isEarlierUnordered;
 exports.packEventIndex = packEventIndex;
 exports.getEventIdKeyString = getEventIdKeyString;
 /* BigInt Not a pure module */