envio 2.22.0 → 2.22.1

package/src/ReorgDetection.res.js

@@ -0,0 +1,223 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+
+function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
+  var scannedBlock = reorgDetected.scannedBlock;
+  return {
+          msg: "Blockchain reorg detected. " + (
+            shouldRollbackOnReorg ? "Initiating indexer rollback" : "NOT initiating indexer rollback due to configuration"
+          ) + ".",
+          blockNumber: scannedBlock.blockNumber,
+          indexedBlockHash: scannedBlock.blockHash,
+          receivedBlockHash: reorgDetected.receivedBlock.blockHash
+        };
+}
+
+function makeWithData(blocks, confirmedBlockThreshold, detectedReorgBlock) {
+  var dataByBlockNumber = {};
+  Belt_Array.forEach(blocks, (function (block) {
+          dataByBlockNumber[block.blockNumber.toString()] = block;
+        }));
+  return {
+          confirmedBlockThreshold: confirmedBlockThreshold,
+          dataByBlockNumber: dataByBlockNumber,
+          detectedReorgBlock: detectedReorgBlock
+        };
+}
+
+function empty(confirmedBlockThreshold) {
+  return {
+          confirmedBlockThreshold: confirmedBlockThreshold,
+          dataByBlockNumber: {},
+          detectedReorgBlock: undefined
+        };
+}
+
+function getDataByBlockNumberCopyInThreshold(param, currentBlockHeight) {
+  var dataByBlockNumber = param.dataByBlockNumber;
+  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  var thresholdBlockNumber = currentBlockHeight - param.confirmedBlockThreshold | 0;
+  var copy = {};
+  for(var idx = 0 ,idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx){
+    var blockNumberKey = ascBlockNumberKeys[idx];
+    var scannedBlock = dataByBlockNumber[blockNumberKey];
+    var isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
+    if (isInReorgThreshold) {
+      copy[blockNumberKey] = scannedBlock;
+    }
+    
+  }
+  return copy;
+}
+
+function registerReorgGuard(self, reorgGuard, currentBlockHeight, shouldRollbackOnReorg) {
+  var confirmedBlockThreshold = self.confirmedBlockThreshold;
+  var dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
+  var prevRangeLastBlock = reorgGuard.prevRangeLastBlock;
+  var rangeLastBlock = reorgGuard.rangeLastBlock;
+  var scannedBlock = dataByBlockNumberCopyInThreshold[String(rangeLastBlock.blockNumber)];
+  var maybeReorgDetected;
+  var exit = 0;
+  if (scannedBlock !== undefined && scannedBlock.blockHash !== rangeLastBlock.blockHash) {
+    maybeReorgDetected = {
+      scannedBlock: scannedBlock,
+      receivedBlock: rangeLastBlock
+    };
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    if (prevRangeLastBlock !== undefined) {
+      var scannedBlock$1 = dataByBlockNumberCopyInThreshold[String(prevRangeLastBlock.blockNumber)];
+      maybeReorgDetected = scannedBlock$1 !== undefined && scannedBlock$1.blockHash !== prevRangeLastBlock.blockHash ? ({
+            scannedBlock: scannedBlock$1,
+            receivedBlock: prevRangeLastBlock
+          }) : undefined;
+    } else {
+      maybeReorgDetected = undefined;
+    }
+  }
+  if (maybeReorgDetected !== undefined) {
+    return [
+            shouldRollbackOnReorg ? ({
+                  confirmedBlockThreshold: self.confirmedBlockThreshold,
+                  dataByBlockNumber: self.dataByBlockNumber,
+                  detectedReorgBlock: maybeReorgDetected.scannedBlock
+                }) : empty(confirmedBlockThreshold),
+            {
+              TAG: "ReorgDetected",
+              _0: maybeReorgDetected
+            }
+          ];
+  } else {
+    dataByBlockNumberCopyInThreshold[String(rangeLastBlock.blockNumber)] = rangeLastBlock;
+    if (prevRangeLastBlock !== undefined) {
+      dataByBlockNumberCopyInThreshold[String(prevRangeLastBlock.blockNumber)] = prevRangeLastBlock;
+    }
+    return [
+            {
+              confirmedBlockThreshold: confirmedBlockThreshold,
+              dataByBlockNumber: dataByBlockNumberCopyInThreshold,
+              detectedReorgBlock: undefined
+            },
+            "NoReorg"
+          ];
+  }
+}
+
+function getLatestValidScannedBlock(self, blockNumbersAndHashes, currentBlockHeight, skipReorgDuplicationCheckOpt) {
+  var skipReorgDuplicationCheck = skipReorgDuplicationCheckOpt !== undefined ? skipReorgDuplicationCheckOpt : false;
+  var verifiedDataByBlockNumber = {};
+  for(var idx = 0 ,idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx){
+    var blockData = blockNumbersAndHashes[idx];
+    verifiedDataByBlockNumber[String(blockData.blockNumber)] = blockData;
+  }
+  var isAlreadyReorgedResponse;
+  if (skipReorgDuplicationCheck) {
+    isAlreadyReorgedResponse = false;
+  } else {
+    var detectedReorgBlock = self.detectedReorgBlock;
+    if (detectedReorgBlock !== undefined) {
+      var verifiedBlockData = verifiedDataByBlockNumber[String(detectedReorgBlock.blockNumber)];
+      isAlreadyReorgedResponse = verifiedBlockData !== undefined ? verifiedBlockData.blockHash === detectedReorgBlock.blockHash : false;
+    } else {
+      isAlreadyReorgedResponse = false;
+    }
+  }
+  if (isAlreadyReorgedResponse) {
+    return {
+            TAG: "Error",
+            _0: "AlreadyReorgedHashes"
+          };
+  }
+  var dataByBlockNumber = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
+  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  var getPrevScannedBlock = function (idx) {
+    var data = Belt_Option.flatMap(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
+            return verifiedDataByBlockNumber[key];
+          }));
+    if (data !== undefined) {
+      return {
+              TAG: "Ok",
+              _0: data
+            };
+    } else {
+      return {
+              TAG: "Error",
+              _0: "NotFound"
+            };
+    }
+  };
+  var _idx = 0;
+  while(true) {
+    var idx$1 = _idx;
+    var blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx$1);
+    if (blockNumberKey === undefined) {
+      return getPrevScannedBlock(idx$1);
+    }
+    var scannedBlock = dataByBlockNumber[blockNumberKey];
+    var verifiedBlockData$1 = verifiedDataByBlockNumber[blockNumberKey];
+    if (verifiedBlockData$1 === undefined) {
+      return Js_exn.raiseError("Unexpected case. Couldn't find verified hash for block number " + blockNumberKey);
+    }
+    if (verifiedBlockData$1.blockHash !== scannedBlock.blockHash) {
+      return getPrevScannedBlock(idx$1);
+    }
+    _idx = idx$1 + 1 | 0;
+    continue ;
+  };
+}
+
+function rollbackToValidBlockNumber(param, blockNumber) {
+  var dataByBlockNumber = param.dataByBlockNumber;
+  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  var newDataByBlockNumber = {};
+  var loop = function (_idx) {
+    while(true) {
+      var idx = _idx;
+      var blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx);
+      if (blockNumberKey === undefined) {
+        return ;
+      }
+      var scannedBlock = dataByBlockNumber[blockNumberKey];
+      var shouldKeep = scannedBlock.blockNumber <= blockNumber;
+      if (!shouldKeep) {
+        return ;
+      }
+      newDataByBlockNumber[blockNumberKey] = scannedBlock;
+      _idx = idx + 1 | 0;
+      continue ;
+    };
+  };
+  loop(0);
+  return {
+          confirmedBlockThreshold: param.confirmedBlockThreshold,
+          dataByBlockNumber: newDataByBlockNumber,
+          detectedReorgBlock: undefined
+        };
+}
+
+function getThresholdBlockNumbers(self, currentBlockHeight) {
+  var dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
+  return Js_dict.values(dataByBlockNumberCopyInThreshold).map(function (v) {
+              return v.blockNumber;
+            });
+}
+
+var LastBlockScannedHashes = {
+  makeWithData: makeWithData,
+  empty: empty,
+  registerReorgGuard: registerReorgGuard,
+  getLatestValidScannedBlock: getLatestValidScannedBlock,
+  getThresholdBlockNumbers: getThresholdBlockNumbers,
+  rollbackToValidBlockNumber: rollbackToValidBlockNumber
+};
+
+exports.reorgDetectedToLogParams = reorgDetectedToLogParams;
+exports.LastBlockScannedHashes = LastBlockScannedHashes;
+/* No side effect */

package/src/Throttler.res.js

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Pino = require("./bindings/Pino.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+function make(intervalMillis, logger) {
+  return {
+          lastRunTimeMillis: 0,
+          isRunning: false,
+          isAwaitingInterval: false,
+          scheduled: undefined,
+          intervalMillis: intervalMillis,
+          logger: logger
+        };
+}
+
+async function startInternal(throttler) {
+  var match = throttler.isRunning;
+  if (match) {
+    return ;
+  }
+  var match$1 = throttler.isAwaitingInterval;
+  if (match$1) {
+    return ;
+  }
+  var fn = throttler.scheduled;
+  if (fn === undefined) {
+    return ;
+  }
+  var timeSinceLastRun = Date.now() - throttler.lastRunTimeMillis;
+  if (timeSinceLastRun >= throttler.intervalMillis) {
+    throttler.isRunning = true;
+    throttler.scheduled = undefined;
+    throttler.lastRunTimeMillis = Date.now();
+    try {
+      await fn();
+    }
+    catch (raw_exn){
+      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      throttler.logger.error(Pino.createPinoMessageWithError("Scheduled action failed in throttler", exn));
+    }
+    throttler.isRunning = false;
+    return await startInternal(throttler);
+  }
+  throttler.isAwaitingInterval = true;
+  setTimeout((function () {
+          throttler.isAwaitingInterval = false;
+          startInternal(throttler);
+        }), throttler.intervalMillis - timeSinceLastRun | 0);
+}
+
+function schedule(throttler, fn) {
+  throttler.scheduled = fn;
+  startInternal(throttler);
+}
+
+exports.make = make;
+exports.schedule = schedule;
+/* Pino Not a pure module */

package/src/Time.res.js

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var Logging = require("./Logging.res.js");
+var Internal = require("./Internal.res.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+function resolvePromiseAfterDelay(delayMilliseconds) {
+  return Utils.delay(delayMilliseconds);
+}
+
+async function retryAsyncWithExponentialBackOff(backOffMillisOpt, multiplicativeOpt, retryCountOpt, maxRetriesOpt, logger, f) {
+  var backOffMillis = backOffMillisOpt !== undefined ? backOffMillisOpt : 100;
+  var multiplicative = multiplicativeOpt !== undefined ? multiplicativeOpt : 4;
+  var retryCount = retryCountOpt !== undefined ? retryCountOpt : 0;
+  var maxRetries = maxRetriesOpt !== undefined ? maxRetriesOpt : 5;
+  try {
+    return await f();
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (retryCount < maxRetries) {
+      var nextRetryCount = retryCount + 1 | 0;
+      var log = retryCount === 0 ? Logging.childTrace : Logging.childWarn;
+      log(logger, {
+            msg: "Retrying query " + String(nextRetryCount) + "/" + String(maxRetries) + " in " + String(backOffMillis) + "ms - waiting for correct result.",
+            err: Internal.prettifyExn(exn)
+          });
+      await Utils.delay(backOffMillis);
+      return await retryAsyncWithExponentialBackOff(Math.imul(backOffMillis, multiplicative), multiplicative, nextRetryCount, maxRetries, logger, f);
+    }
+    ErrorHandling.log(ErrorHandling.make(exn, logger, "Failure. Max retries " + String(retryCount) + "/" + String(maxRetries) + " exceeded"));
+    return await Promise.reject(Caml_js_exceptions.internalToOCamlException(exn));
+  }
+}
+
+exports.resolvePromiseAfterDelay = resolvePromiseAfterDelay;
+exports.retryAsyncWithExponentialBackOff = retryAsyncWithExponentialBackOff;
+/* Utils Not a pure module */

package/src/TopicFilter.res.js

@@ -0,0 +1,86 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Viem = require("viem");
+var $$BigInt = require("./bindings/BigInt.res.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+
+function toTwosComplement(num, bytesLen) {
+  var maxValue = $$BigInt.Bitwise.shift_left(1n, BigInt((bytesLen << 3)));
+  var mask = $$BigInt.sub(maxValue, 1n);
+  return $$BigInt.Bitwise.logand($$BigInt.add(num, maxValue), mask);
+}
+
+function fromSignedBigInt(val) {
+  var val$1 = val >= 0n ? val : toTwosComplement(val, 32);
+  return Viem.numberToHex(val$1, {
+              size: 32
+            });
+}
+
+function keccak256(prim) {
+  return Viem.keccak256(prim);
+}
+
+function bytesToHex(prim0, prim1) {
+  return Viem.bytesToHex(prim0, prim1 !== undefined ? Caml_option.valFromOption(prim1) : undefined);
+}
+
+function concat(prim) {
+  return Viem.concat(prim);
+}
+
+function castToHexUnsafe(val) {
+  return val;
+}
+
+function fromBigInt(val) {
+  return Viem.numberToHex(val, {
+              size: 32
+            });
+}
+
+function fromDynamicString(val) {
+  return Viem.keccak256(val);
+}
+
+function fromString(val) {
+  return Viem.stringToHex(val, {
+              size: 32
+            });
+}
+
+function fromAddress(addr) {
+  return Viem.pad(addr);
+}
+
+function fromDynamicBytes(bytes) {
+  return Viem.keccak256(bytes);
+}
+
+function fromBytes(bytes) {
+  return Viem.bytesToHex(bytes, {
+              size: 32
+            });
+}
+
+function fromBool(b) {
+  return Viem.boolToHex(b, {
+              size: 32
+            });
+}
+
+exports.toTwosComplement = toTwosComplement;
+exports.fromSignedBigInt = fromSignedBigInt;
+exports.keccak256 = keccak256;
+exports.bytesToHex = bytesToHex;
+exports.concat = concat;
+exports.castToHexUnsafe = castToHexUnsafe;
+exports.fromBigInt = fromBigInt;
+exports.fromDynamicString = fromDynamicString;
+exports.fromString = fromString;
+exports.fromAddress = fromAddress;
+exports.fromDynamicBytes = fromDynamicBytes;
+exports.fromBytes = fromBytes;
+exports.fromBool = fromBool;
+/* viem Not a pure module */