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

package/src/FetchState.res.js

@@ -5,10 +5,12 @@ var Caml = require("rescript/lib/js/caml.js");
 var Utils = require("./Utils.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Js_dict = require("rescript/lib/js/js_dict.js");
+var Js_math = require("rescript/lib/js/js_math.js");
 var Logging = require("./Logging.res.js");
 var Belt_Int = require("rescript/lib/js/belt_Int.js");
 var Caml_obj = require("rescript/lib/js/caml_obj.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_int32 = require("rescript/lib/js/caml_int32.js");
 var Prometheus = require("./Prometheus.res.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var Belt_Result = require("rescript/lib/js/belt_Result.js");
@@ -20,9 +22,9 @@ function copy(fetchState) {
           partitions: fetchState.partitions,
           nextPartitionIndex: fetchState.nextPartitionIndex,
           isFetchingAtHead: fetchState.isFetchingAtHead,
+          startBlock: fetchState.startBlock,
           endBlock: fetchState.endBlock,
           maxAddrInPartition: fetchState.maxAddrInPartition,
-          firstEventBlockNumber: fetchState.firstEventBlockNumber,
           normalSelection: fetchState.normalSelection,
           indexingContracts: fetchState.indexingContracts,
           contractConfigs: fetchState.contractConfigs,
@@ -30,7 +32,8 @@ function copy(fetchState) {
           chainId: fetchState.chainId,
           latestFullyFetchedBlock: fetchState.latestFullyFetchedBlock,
           blockLag: fetchState.blockLag,
-          queue: fetchState.queue.slice(0)
+          queue: fetchState.queue.slice(0),
+          onBlockConfigs: fetchState.onBlockConfigs
         };
 }
 
@@ -137,14 +140,13 @@ function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexi
   Prometheus.IndexingPartitions.set(partitions.length, fetchState.chainId);
   Prometheus.IndexingBufferSize.set(bufferSize, fetchState.chainId);
   Prometheus.IndexingBufferBlockNumber.set(latestFullyFetchedBlock$1.blockNumber, fetchState.chainId);
-  var item = Utils.$$Array.last(queue);
   return {
           partitions: partitions,
           nextPartitionIndex: nextPartitionIndex,
           isFetchingAtHead: isFetchingAtHead,
+          startBlock: fetchState.startBlock,
           endBlock: fetchState.endBlock,
           maxAddrInPartition: fetchState.maxAddrInPartition,
-          firstEventBlockNumber: item !== undefined ? Utils.$$Math.minOptInt(fetchState.firstEventBlockNumber, item.blockNumber) : fetchState.firstEventBlockNumber,
           normalSelection: fetchState.normalSelection,
           indexingContracts: indexingContracts,
           contractConfigs: fetchState.contractConfigs,
@@ -152,7 +154,8 @@ function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexi
           chainId: fetchState.chainId,
           latestFullyFetchedBlock: latestFullyFetchedBlock$1,
           blockLag: blockLag,
-          queue: queue
+          queue: queue,
+          onBlockConfigs: fetchState.onBlockConfigs
         };
 }
 
@@ -409,7 +412,46 @@ function handleQueryResult(fetchState, query, latestFetchedBlock, newItems, curr
     };
   }
   return Belt_Result.map(tmp, (function (partitions) {
-                return updateInternal(fetchState, partitions, undefined, undefined, undefined, currentBlockHeight, Belt_Array.concat(fetchState.queue, newItems).sort(compareBufferItem), undefined);
+                var newQueue = Belt_Array.concat(fetchState.queue, newItems);
+                var onBlockConfigs = fetchState.onBlockConfigs;
+                if (onBlockConfigs !== undefined) {
+                  var prevLatestFetchedBlockNumber = fetchState.latestFullyFetchedBlock.blockNumber;
+                  var nextLatestFullyFetchedBlockNumber = latestFetchedBlock.blockNumber;
+                  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
+                    var p = partitions[idx];
+                    if (nextLatestFullyFetchedBlockNumber > p.latestFetchedBlock.blockNumber) {
+                      nextLatestFullyFetchedBlockNumber = p.latestFetchedBlock.blockNumber;
+                    }
+                    
+                  }
+                  var nextLatestFullyFetchedBlockNumber$1 = nextLatestFullyFetchedBlockNumber;
+                  if (nextLatestFullyFetchedBlockNumber$1 > prevLatestFetchedBlockNumber) {
+                    for(var configIdx = 0 ,configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx){
+                      var onBlockConfig = onBlockConfigs[configIdx];
+                      var startBlock = onBlockConfig.startBlock;
+                      var handlerStartBlock = startBlock !== undefined ? startBlock : fetchState.startBlock;
+                      var rangeStart = Caml.int_max(handlerStartBlock, prevLatestFetchedBlockNumber + 1 | 0);
+                      var endBlock = onBlockConfig.endBlock;
+                      var rangeEnd = endBlock !== undefined && endBlock < nextLatestFullyFetchedBlockNumber$1 ? endBlock : nextLatestFullyFetchedBlockNumber$1;
+                      if (rangeStart <= rangeEnd) {
+                        for(var blockNumber = rangeStart; blockNumber <= rangeEnd; ++blockNumber){
+                          if (Caml_int32.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
+                            newQueue.push({
+                                  kind: 1,
+                                  onBlockConfig: onBlockConfig,
+                                  blockNumber: blockNumber,
+                                  logIndex: 16777216
+                                });
+                          }
+                          
+                        }
+                      }
+                      
+                    }
+                  }
+                  
+                }
+                return updateInternal(fetchState, partitions, undefined, undefined, undefined, currentBlockHeight, newQueue.sort(compareBufferItem), undefined);
               }));
 }
 
@@ -632,18 +674,6 @@ function getNextQuery(param, concurrencyLimit, targetBufferSize, currentBlockHei
   }
 }
 
-function queueItemBlockNumber(queueItem) {
-  if (queueItem.TAG === "Item") {
-    return queueItem._0.item.blockNumber;
-  }
-  var blockNumber = queueItem.latestFetchedBlock.blockNumber;
-  if (blockNumber === 0) {
-    return 0;
-  } else {
-    return blockNumber + 1 | 0;
-  }
-}
-
 function makeNoItem(param) {
   return {
           TAG: "NoItem",
@@ -651,28 +681,6 @@ function makeNoItem(param) {
         };
 }
 
-function qItemLt(a, b) {
-  var aBlockNumber = queueItemBlockNumber(a);
-  var bBlockNumber = queueItemBlockNumber(b);
-  if (aBlockNumber < bBlockNumber) {
-    return true;
-  } else if (aBlockNumber === bBlockNumber) {
-    if (a.TAG === "Item") {
-      if (b.TAG === "Item") {
-        return a._0.item.logIndex < b._0.item.logIndex;
-      } else {
-        return false;
-      }
-    } else if (b.TAG === "Item") {
-      return true;
-    } else {
-      return false;
-    }
-  } else {
-    return false;
-  }
-}
-
 function getEarliestEvent(param) {
   var queue = param.queue;
   var latestFullyFetchedBlock = param.latestFullyFetchedBlock;
@@ -695,11 +703,11 @@ function getEarliestEvent(param) {
   }
 }
 
-function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, blockLagOpt) {
+function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, progressBlockNumberOpt, onBlockConfigs, blockLagOpt) {
+  var progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   var blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
-  var latestFetchedBlock_blockNumber = startBlock - 1 | 0;
   var latestFetchedBlock = {
-    blockNumber: latestFetchedBlock_blockNumber,
+    blockNumber: progressBlockNumber,
     blockTimestamp: 0
   };
   var notDependingOnAddresses = [];
@@ -786,7 +794,7 @@ function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition,
   Prometheus.IndexingAddresses.set(numAddresses, chainId);
   Prometheus.IndexingPartitions.set(partitions.length, chainId);
   Prometheus.IndexingBufferSize.set(0, chainId);
-  Prometheus.IndexingBufferBlockNumber.set(latestFetchedBlock_blockNumber, chainId);
+  Prometheus.IndexingBufferBlockNumber.set(progressBlockNumber, chainId);
   if (endBlock !== undefined) {
     Prometheus.IndexingEndBlock.set(endBlock, chainId);
   }
@@ -794,9 +802,9 @@ function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition,
           partitions: partitions,
           nextPartitionIndex: partitions.length,
           isFetchingAtHead: false,
+          startBlock: startBlock,
           endBlock: endBlock,
           maxAddrInPartition: maxAddrInPartition,
-          firstEventBlockNumber: undefined,
           normalSelection: normalSelection,
           indexingContracts: indexingContracts,
           contractConfigs: contractConfigs,
@@ -804,7 +812,8 @@ function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition,
           chainId: chainId,
           latestFullyFetchedBlock: latestFetchedBlock,
           blockLag: blockLag,
-          queue: []
+          queue: [],
+          onBlockConfigs: onBlockConfigs
         };
 }
 
@@ -818,10 +827,15 @@ function getLatestFullyFetchedBlock(param) {
 
 function pruneQueueFromFirstChangeEvent(queue, firstChangeEvent) {
   return Belt_Array.keep(queue, (function (item) {
-                return Caml_obj.lessthan([
-                            item.blockNumber,
-                            item.logIndex
-                          ], [
+                var tmp;
+                tmp = item.kind === 0 ? [
+                    item.blockNumber,
+                    item.logIndex
+                  ] : [
+                    item.blockNumber,
+                    item.logIndex
+                  ];
+                return Caml_obj.lessthan(tmp, [
                             firstChangeEvent.blockNumber,
                             firstChangeEvent.logIndex
                           ]);
@@ -956,7 +970,13 @@ function filterAndSortForUnorderedBatch(fetchStates, maxBatchSize) {
               } else if (match$1) {
                 return 1;
               }
-              return Utils.$$Array.lastUnsafe(a.queue).timestamp - Utils.$$Array.lastUnsafe(b.queue).timestamp | 0;
+              var match$2 = Utils.$$Array.lastUnsafe(a.queue);
+              var match$3 = Utils.$$Array.lastUnsafe(b.queue);
+              if (match$2.kind === 0 && match$3.kind === 0) {
+                return match$2.timestamp - match$3.timestamp | 0;
+              } else {
+                return Js_math.random_int(-1, 1);
+              }
             });
 }
 
@@ -971,13 +991,22 @@ function getProgressBlockNumber(param) {
 }
 
 function getProgressNextBlockLogIndex(param) {
-  var item = Utils.$$Array.last(param.queue);
-  if (item !== undefined && param.latestFullyFetchedBlock.blockNumber >= item.blockNumber && item.logIndex > 0) {
-    return item.logIndex - 1 | 0;
+  var match = Utils.$$Array.last(param.queue);
+  if (match === undefined) {
+    return ;
+  }
+  if (match.kind !== 0) {
+    return ;
+  }
+  var logIndex = match.logIndex;
+  if (param.latestFullyFetchedBlock.blockNumber >= match.blockNumber && logIndex > 0) {
+    return logIndex - 1 | 0;
   }
   
 }
 
+var blockItemLogIndex = 16777216;
+
 exports.copy = copy;
 exports.mergeIntoPartition = mergeIntoPartition;
 exports.checkIsWithinSyncRange = checkIsWithinSyncRange;
@@ -988,6 +1017,7 @@ exports.registerDynamicContracts = registerDynamicContracts;
 exports.UnexpectedPartitionNotFound = UnexpectedPartitionNotFound;
 exports.UnexpectedMergeQueryResponse = UnexpectedMergeQueryResponse;
 exports.compareBufferItem = compareBufferItem;
+exports.blockItemLogIndex = blockItemLogIndex;
 exports.handleQueryResult = handleQueryResult;
 exports.makePartitionQuery = makePartitionQuery;
 exports.startFetchingQueries = startFetchingQueries;
@@ -995,9 +1025,7 @@ exports.addressesByContractNameCount = addressesByContractNameCount;
 exports.addressesByContractNameGetAll = addressesByContractNameGetAll;
 exports.isFullPartition = isFullPartition;
 exports.getNextQuery = getNextQuery;
-exports.queueItemBlockNumber = queueItemBlockNumber;
 exports.makeNoItem = makeNoItem;
-exports.qItemLt = qItemLt;
 exports.getEarliestEvent = getEarliestEvent;
 exports.make = make;
 exports.bufferSize = bufferSize;

package/src/Internal.gen.ts

@@ -51,6 +51,8 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly preRegisterDynamicContracts?: boolean
 };
 
+export type blockEvent = { readonly number: number; readonly chainId: number };
+
 export type eventOptions<eventFilters> = {
   readonly wildcard?: boolean; 
   readonly eventFilters?: eventFilters; 

package/src/Internal.res

@@ -133,17 +133,61 @@ type evmContractConfig = {
   events: array<evmEventConfig>,
 }
 
-type eventItem = {
+// Duplicate the type from item
+// to make item properly unboxed
+type eventItem = private {
+  kind: [#0],
   eventConfig: eventConfig,
   timestamp: int,
   chain: ChainMap.Chain.t,
   blockNumber: int,
   logIndex: int,
   event: event,
-  // Reuse logger object for event
-  mutable loggerCache?: Pino.t,
 }
 
+@genType
+type blockEvent = {
+  number: int,
+  chainId: int,
+}
+
+type onBlockArgs = {
+  block: blockEvent,
+  context: handlerContext,
+}
+
+type onBlockConfig = {
+  // When there are multiple onBlock handlers per chain,
+  // we want to use the order they are defined for sorting
+  index: int,
+  name: string,
+  chainId: int,
+  startBlock: option<int>,
+  endBlock: option<int>,
+  interval: int,
+  handler: onBlockArgs => promise<unit>,
+}
+
+@tag("kind")
+type item =
+  | @as(0)
+  Event({
+      eventConfig: eventConfig,
+      timestamp: int,
+      chain: ChainMap.Chain.t,
+      blockNumber: int,
+      logIndex: int,
+      event: event,
+    })
+  | @as(1) Block({onBlockConfig: onBlockConfig, blockNumber: int, logIndex: int})
+
+external castUnsafeEventItem: item => eventItem = "%identity"
+
+@get
+external getItemBlockNumber: item => int = "blockNumber"
+@get
+external getItemLogIndex: item => int = "logIndex"
+
 @genType
 type eventOptions<'eventFilters> = {
   wildcard?: bool,

package/src/InternalConfig.res

@@ -2,6 +2,22 @@
 // And turn it into PublicConfig instead
 // For internal use we should create Indexer.res with a stateful type
 
+type ecosystem = | @as("evm") Evm | @as("fuel") Fuel
+
+type sourceSyncOptions = {
+  initialBlockInterval?: int,
+  backoffMultiplicative?: float,
+  accelerationAdditive?: int,
+  intervalCeiling?: int,
+  backoffMillis?: int,
+  queryTimeoutMillis?: int,
+  fallbackStallTimeout?: int,
+}
+
+type historyFlag = FullHistory | MinHistory
+type rollbackFlag = RollbackOnReorg | NoRollback
+type historyConfig = {rollbackFlag: rollbackFlag, historyFlag: historyFlag}
+
 type contract = {
   name: string,
   abi: EvmTypes.Abi.t,
@@ -28,3 +44,5 @@ type sourceSync = {
   queryTimeoutMillis: int,
   fallbackStallTimeout: int,
 }
+
+type multichain = | @as("ordered") Ordered | @as("unordered") Unordered

package/src/Logging.res

@@ -144,29 +144,41 @@ let createChildFrom = (~logger: t, ~params: 'a) => {
   logger->child(params->createChildParams)
 }
 
-let getEventLogger = (eventItem: Internal.eventItem) => {
-  switch eventItem.loggerCache {
-  | Some(l) => l
-  | None => {
-      let l = getLogger()->child(
-        {
-          "contractName": eventItem.eventConfig.contractName,
-          "eventName": eventItem.eventConfig.name,
-          "chainId": eventItem.chain->ChainMap.Chain.toChainId,
-          "block": eventItem.blockNumber,
-          "logIndex": eventItem.logIndex,
-          "address": eventItem.event.srcAddress,
-        }->createChildParams,
-      )
-      eventItem.loggerCache = Some(l)
-      l
+let getItemLogger = {
+  let cacheKey = "_logger"
+  (item: Internal.item) => {
+    switch item->Utils.magic->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
+    | Some(l) => l
+    | None => {
+        let l = getLogger()->child(
+          switch item {
+          | Event({eventConfig, chain, blockNumber, logIndex, event}) =>
+            {
+              "contractName": eventConfig.contractName,
+              "eventName": eventConfig.name,
+              "chainId": chain->ChainMap.Chain.toChainId,
+              "block": blockNumber,
+              "logIndex": logIndex,
+              "address": event.srcAddress,
+            }->createChildParams
+          | Block({blockNumber, onBlockConfig}) =>
+            {
+              "onBlock": onBlockConfig.name,
+              "chainId": onBlockConfig.chainId,
+              "block": blockNumber,
+            }->createChildParams
+          },
+        )
+        item->Utils.magic->Js.Dict.set(cacheKey, l)
+        l
+      }
     }
   }
 }
 
 @inline
-let logForItem = (eventItem, level: Pino.logLevel, message: string, ~params=?) => {
-  (eventItem->getEventLogger->Utils.magic->Js.Dict.unsafeGet((level :> string)))(params, message)
+let logForItem = (item, level: Pino.logLevel, message: string, ~params=?) => {
+  (item->getItemLogger->Utils.magic->Js.Dict.unsafeGet((level :> string)))(params, message)
 }
 
 let noopLogger: Envio.logger = {
@@ -177,11 +189,11 @@ let noopLogger: Envio.logger = {
   errorWithExn: (_message: string, _exn) => (),
 }
 
-let getUserLogger = (eventItem): Envio.logger => {
-  info: (message: string, ~params=?) => eventItem->logForItem(#uinfo, message, ~params?),
-  debug: (message: string, ~params=?) => eventItem->logForItem(#udebug, message, ~params?),
-  warn: (message: string, ~params=?) => eventItem->logForItem(#uwarn, message, ~params?),
-  error: (message: string, ~params=?) => eventItem->logForItem(#uerror, message, ~params?),
+let getUserLogger = (item): Envio.logger => {
+  info: (message: string, ~params=?) => item->logForItem(#uinfo, message, ~params?),
+  debug: (message: string, ~params=?) => item->logForItem(#udebug, message, ~params?),
+  warn: (message: string, ~params=?) => item->logForItem(#uwarn, message, ~params?),
+  error: (message: string, ~params=?) => item->logForItem(#uerror, message, ~params?),
   errorWithExn: (message: string, exn) =>
-    eventItem->logForItem(#uerror, message, ~params={"err": exn->Utils.prettifyExn}),
+    item->logForItem(#uerror, message, ~params={"err": exn->Utils.prettifyExn}),
 }

package/src/Logging.res.js

@@ -177,25 +177,39 @@ function createChildFrom(logger, params) {
   return logger.child(Pino.createChildParams(params));
 }
 
-function getEventLogger(eventItem) {
-  var l = eventItem.loggerCache;
+var cacheKey = "_logger";
+
+function getItemLogger(item) {
+  var l = item[cacheKey];
   if (l !== undefined) {
-    return l;
+    return Caml_option.valFromOption(l);
   }
-  var l$1 = getLogger().child(Pino.createChildParams({
-            contractName: eventItem.eventConfig.contractName,
-            eventName: eventItem.eventConfig.name,
-            chainId: eventItem.chain,
-            block: eventItem.blockNumber,
-            logIndex: eventItem.logIndex,
-            address: eventItem.event.srcAddress
-          }));
-  eventItem.loggerCache = l$1;
+  var tmp;
+  if (item.kind === 0) {
+    var eventConfig = item.eventConfig;
+    tmp = Pino.createChildParams({
+          contractName: eventConfig.contractName,
+          eventName: eventConfig.name,
+          chainId: item.chain,
+          block: item.blockNumber,
+          logIndex: item.logIndex,
+          address: item.event.srcAddress
+        });
+  } else {
+    var onBlockConfig = item.onBlockConfig;
+    tmp = Pino.createChildParams({
+          onBlock: onBlockConfig.name,
+          chainId: onBlockConfig.chainId,
+          block: item.blockNumber
+        });
+  }
+  var l$1 = getLogger().child(tmp);
+  item[cacheKey] = l$1;
   return l$1;
 }
 
-function logForItem(eventItem, level, message, params) {
-  return getEventLogger(eventItem)[level](params, message);
+function logForItem(item, level, message, params) {
+  return getItemLogger(item)[level](params, message);
 }
 
 function noopLogger_debug(_message, param) {
@@ -226,25 +240,25 @@ var noopLogger = {
   errorWithExn: noopLogger_errorWithExn
 };
 
-function getUserLogger(eventItem) {
+function getUserLogger(item) {
   return {
           debug: (function (message, params) {
-              getEventLogger(eventItem)["udebug"](params, message);
+              getItemLogger(item)["udebug"](params, message);
             }),
           info: (function (message, params) {
-              getEventLogger(eventItem)["uinfo"](params, message);
+              getItemLogger(item)["uinfo"](params, message);
             }),
           warn: (function (message, params) {
-              getEventLogger(eventItem)["uwarn"](params, message);
+              getItemLogger(item)["uwarn"](params, message);
             }),
           error: (function (message, params) {
-              getEventLogger(eventItem)["uerror"](params, message);
+              getItemLogger(item)["uerror"](params, message);
             }),
           errorWithExn: (function (message, exn) {
               var params = {
                 err: Utils.prettifyExn(exn)
               };
-              getEventLogger(eventItem)["uerror"](params, message);
+              getItemLogger(item)["uerror"](params, message);
             })
         };
 }
@@ -270,7 +284,7 @@ exports.childErrorWithExn = childErrorWithExn;
 exports.childFatal = childFatal;
 exports.createChild = createChild;
 exports.createChildFrom = createChildFrom;
-exports.getEventLogger = getEventLogger;
+exports.getItemLogger = getItemLogger;
 exports.logForItem = logForItem;
 exports.noopLogger = noopLogger;
 exports.getUserLogger = getUserLogger;