envio 3.0.2 → 3.1.0-rc.1

package/src/sources/HyperSyncSource.res.mjs

@@ -1,27 +1,23 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Internal from "../Internal.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "../Prometheus.res.mjs";
 import * as EventRouter from "./EventRouter.res.mjs";
 import * as LogSelection from "../LogSelection.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
-import * as HyperSyncJsonApi from "./HyperSyncJsonApi.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as HyperSyncHeightStream from "./HyperSyncHeightStream.res.mjs";
 
 function getSelectionConfig(selection, chain) {
-  let nonOptionalBlockFieldNames = new Set();
-  let nonOptionalTransactionFieldNames = new Set();
   let capitalizedBlockFields = new Set();
   let capitalizedTransactionFields = new Set();
   let staticTopicSelectionsByContract = {};
@@ -32,15 +28,9 @@ function getSelectionConfig(selection, chain) {
   selection.eventConfigs.forEach(param => {
     let contractName = param.contractName;
     Array.from(param.selectedBlockFields).forEach(name => {
-      if (!Internal.evmNullableBlockFields.has(name)) {
-        nonOptionalBlockFieldNames.add(name);
-      }
       capitalizedBlockFields.add(Utils.$$String.capitalize(name));
     });
     Array.from(param.selectedTransactionFields).forEach(name => {
-      if (!Internal.evmNullableTransactionFields.has(name)) {
-        nonOptionalTransactionFieldNames.add(name);
-      }
       capitalizedTransactionFields.add(Utils.$$String.capitalize(name));
     });
     let eventFilters = param.getEventFiltersOrThrow(chain);
@@ -104,9 +94,7 @@ function getSelectionConfig(selection, chain) {
   };
   return {
     getLogSelectionOrThrow: getLogSelectionOrThrow,
-    fieldSelection: fieldSelection,
-    nonOptionalBlockFieldNames: Array.from(nonOptionalBlockFieldNames),
-    nonOptionalTransactionFieldNames: Array.from(nonOptionalTransactionFieldNames)
+    fieldSelection: fieldSelection
   };
 }
 
@@ -114,11 +102,13 @@ function memoGetSelectionConfig(chain) {
   return Utils.$$WeakMap.memoize(selection => getSelectionConfig(selection, chain));
 }
 
+function isUnauthorizedError(message) {
+  return message.includes("401 Unauthorized");
+}
+
 function make(param) {
-  let lowercaseAddresses = param.lowercaseAddresses;
   let apiToken = param.apiToken;
   let eventRouter = param.eventRouter;
-  let allEventSignatures = param.allEventSignatures;
   let endpointUrl = param.endpointUrl;
   let chain = param.chain;
   let name = "HyperSync";
@@ -126,54 +116,37 @@ function make(param) {
   let apiToken$1 = apiToken !== undefined ? apiToken : Stdlib_JsError.throwWithMessage(`An API token is required for using HyperSync as a data-source.
 Set the ENVIO_API_TOKEN environment variable in your .env file.
 Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
-  let client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, param.clientMaxRetries, !lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined);
-  let hscDecoder = {
-    contents: undefined
-  };
-  let getHscDecoder = () => {
-    let decoder = hscDecoder.contents;
-    if (decoder !== undefined) {
-      return decoder;
-    }
-    let decoder$1;
-    try {
-      decoder$1 = HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      return ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate a decoder from hypersync client, please double check your ABI", exn);
-    }
-    if (lowercaseAddresses) {
-      decoder$1.disableChecksummedAddresses();
-    } else {
-      decoder$1.enableChecksummedAddresses();
-    }
-    return decoder$1;
-  };
+  let client;
+  try {
+    client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, param.allEventParams, !param.lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined, param.logLevel);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    client = ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate the hypersync client, please double check your ABI", exn);
+  }
   let UndefinedValue = /* @__PURE__ */Primitive_exceptions.create("UndefinedValue");
   let makeEventBatchQueueItem = (item, params, eventConfig) => {
     let block = item.block;
-    let log = item.log;
+    let logIndex = item.logIndex;
     return {
       kind: 0,
       eventConfig: eventConfig,
       timestamp: block.timestamp,
       chain: chain,
       blockNumber: block.number,
-      logIndex: log.logIndex,
+      logIndex: logIndex,
       event: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
         params: params,
         chainId: chain,
-        srcAddress: log.address,
-        logIndex: log.logIndex,
+        srcAddress: item.srcAddress,
+        logIndex: logIndex,
         transaction: item.transaction,
         block: block
       }
     };
   };
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, param, selection, retry, logger) => {
-    let mkLogAndRaise = (extra, extra$1) => ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     let totalTimeRef = Hrtime.makeTimer();
     let selectionConfig = getSelectionConfig(selection);
     let logSelections;
@@ -187,7 +160,7 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     Prometheus.SourceRequestCount.increment(name, chain, "getLogs");
     let pageUnsafe;
     try {
-      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, logSelections, selectionConfig.fieldSelection, selectionConfig.nonOptionalBlockFieldNames, selectionConfig.nonOptionalTransactionFieldNames);
+      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, logSelections, selectionConfig.fieldSelection);
     } catch (raw_error) {
       let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {
@@ -217,6 +190,9 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
           Error: new Error()
         };
       }
+      if (error.RE_EXN_ID === Source.RateLimited) {
+        throw error;
+      }
       throw {
         RE_EXN_ID: Source.GetItemsError,
         _1: {
@@ -235,73 +211,22 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
-    let match = pageUnsafe.rollbackGuard;
-    let lastBlockQueriedPromise;
-    if (match !== undefined) {
-      lastBlockQueriedPromise = Promise.resolve({
-        blockHash: match.hash,
-        blockNumber: match.blockNumber,
-        blockTimestamp: match.timestamp
-      });
-    } else {
-      let match$1 = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
-      let exit = 0;
-      if (match$1 !== undefined) {
-        let block = match$1.block;
-        if (block.number === heighestBlockQueried) {
-          lastBlockQueriedPromise = Promise.resolve({
-            blockHash: block.hash,
-            blockNumber: block.number,
-            blockTimestamp: block.timestamp
-          });
-        } else {
-          exit = 1;
-        }
-      } else {
-        exit = 1;
-      }
-      if (exit === 1) {
-        lastBlockQueriedPromise = HyperSync.queryBlockData(client, heighestBlockQueried, name, chain, logger).then(res => {
-          if (res.TAG !== "Ok") {
-            return mkLogAndRaise(`Failed to query blockData for block ` + heighestBlockQueried.toString(), HyperSync.queryErrorToMsq(res._0));
-          }
-          let blockData = res._0;
-          if (blockData !== undefined) {
-            return blockData;
-          } else {
-            return mkLogAndRaise(`Failure, blockData for block ` + heighestBlockQueried.toString() + ` unexpectedly returned None`, {
-              RE_EXN_ID: "Not_found"
-            });
-          }
-        });
-      }
-    }
     let parsingTimeRef = Hrtime.makeTimer();
     let parsedQueueItems = [];
-    let parsedEvents;
-    try {
-      parsedEvents = await getHscDecoder().decodeEvents(pageUnsafe.events);
-    } catch (raw_exn$1) {
-      let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-      parsedEvents = mkLogAndRaise("Failed to parse events using hypersync client, please double check your ABI.", exn$1);
-    }
-    Belt_Array.forEachWithIndex(pageUnsafe.items, (index, item) => {
-      let block = item.block;
-      let log = item.log;
-      let topic0 = Utils.$$Array.firstUnsafe(log.topics);
-      let maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, block.number, indexingAddresses);
-      let maybeDecodedEvent = parsedEvents[index];
+    Belt_Array.forEach(pageUnsafe.items, item => {
+      let maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(item.topic0, item.topicCount), item.srcAddress, item.block.number, indexingAddresses);
+      let match = item.params;
       if (maybeEventConfig === undefined) {
         return;
       }
-      if (maybeDecodedEvent == null) {
-        maybeDecodedEvent === null;
+      if (match == null) {
+        match === null;
       } else {
-        parsedQueueItems.push(makeEventBatchQueueItem(item, maybeEventConfig.convertHyperSyncEventArgs(maybeDecodedEvent), maybeEventConfig));
+        parsedQueueItems.push(makeEventBatchQueueItem(item, match, maybeEventConfig));
         return;
       }
-      let logIndex = log.logIndex;
-      let blockNumber = block.number;
+      let logIndex = item.logIndex;
+      let blockNumber = item.block.number;
       let exn = {
         RE_EXN_ID: UndefinedValue
       };
@@ -318,15 +243,43 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
       ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
     });
     let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
-    let rangeLastBlock = await lastBlockQueriedPromise;
-    let reorgGuard_prevRangeLastBlock = Stdlib_Option.map(pageUnsafe.rollbackGuard, v => ({
-      blockHash: v.firstParentHash,
-      blockNumber: v.firstBlockNumber - 1 | 0
-    }));
-    let reorgGuard = {
-      rangeLastBlock: rangeLastBlock,
-      prevRangeLastBlock: reorgGuard_prevRangeLastBlock
-    };
+    let blockHashes = [];
+    Belt_Array.forEach(pageUnsafe.items, param => {
+      let block = param.block;
+      let match = block.number;
+      let match$1 = block.hash;
+      if (match !== undefined && match$1 !== undefined) {
+        blockHashes.push({
+          blockHash: match$1,
+          blockNumber: match
+        });
+        return;
+      }
+    });
+    let match = pageUnsafe.rollbackGuard;
+    if (match !== undefined) {
+      blockHashes.push({
+        blockHash: match.hash,
+        blockNumber: match.blockNumber
+      });
+      blockHashes.push({
+        blockHash: match.firstParentHash,
+        blockNumber: match.firstBlockNumber - 1 | 0
+      });
+    }
+    let match$1 = pageUnsafe.rollbackGuard;
+    let latestFetchedBlockTimestamp;
+    if (match$1 !== undefined) {
+      latestFetchedBlockTimestamp = match$1.timestamp;
+    } else {
+      let match$2 = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
+      if (match$2 !== undefined) {
+        let block = match$2.block;
+        latestFetchedBlockTimestamp = block.number === heighestBlockQueried ? block.timestamp : 0;
+      } else {
+        latestFetchedBlockTimestamp = 0;
+      }
+    }
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
     let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
@@ -337,16 +290,15 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     };
     return {
       knownHeight: knownHeight$1,
-      reorgGuard: reorgGuard,
+      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       fromBlockQueried: fromBlock,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockNumber: heighestBlockQueried,
+      latestFetchedBlockTimestamp: latestFetchedBlockTimestamp,
       stats: stats
     };
   };
   let getBlockHashes = (blockNumbers, logger) => HyperSync.queryBlockDataMulti(client, blockNumbers, name, chain, logger).then(HyperSync.mapExn);
-  let jsonApiClient = Rest.client(endpointUrl, undefined);
   return {
     name: name,
     sourceFor: "Sync",
@@ -356,16 +308,36 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
       let timerRef = Hrtime.makeTimer();
-      let height = await Rest.fetch(HyperSyncJsonApi.heightRoute, apiToken$1, jsonApiClient);
       let result;
-      if (typeof height === "number") {
-        result = height;
-      } else if (height === `Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.`) {
-        Logging.error(`Your ENVIO_API_TOKEN is malformed. The indexer will not be able to fetch events. Update the token and restart the indexer using 'pnpm envio start'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens`);
-        await new Promise((param, param$1) => {});
-        result = 0;
-      } else {
-        result = Stdlib_JsError.throwWithMessage(height);
+      try {
+        result = await client.getHeight();
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        if (e.RE_EXN_ID === "JsExn") {
+          let e$1 = e._1;
+          let message = Stdlib_JsExn.message(e$1);
+          if (message !== undefined) {
+            if (message.includes("401 Unauthorized")) {
+              Logging.error(`Your ENVIO_API_TOKEN was rejected by HyperSync (401 Unauthorized). The indexer will not be able to fetch events. Update the token and try again using 'envio start' or 'envio dev'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens`);
+              await new Promise((param, param$1) => {});
+              result = 0;
+            } else {
+              throw {
+                RE_EXN_ID: "JsExn",
+                _1: e$1,
+                Error: new Error()
+              };
+            }
+          } else {
+            throw {
+              RE_EXN_ID: "JsExn",
+              _1: e$1,
+              Error: new Error()
+            };
+          }
+        } else {
+          throw e;
+        }
       }
       let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
       Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
@@ -380,6 +352,7 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
 export {
   getSelectionConfig,
   memoGetSelectionConfig,
+  isUnauthorizedError,
   make,
 }
-/* Rest Not a pure module */
+/* Utils Not a pure module */

package/src/sources/RpcSource.res

@@ -7,6 +7,7 @@ type blockInfo = {
   number: int,
   timestamp: int,
   hash: string,
+  parentHash: string,
 }
 
 let getKnownRawBlock = async (~client, ~blockNumber) =>
@@ -29,6 +30,9 @@ let parseBlockInfo = (json: JSON.t): blockInfo => {
     hash: jsonDict
     ->Dict.getUnsafe("hash")
     ->S.parseOrThrow(S.string),
+    parentHash: jsonDict
+    ->Dict.getUnsafe("parentHash")
+    ->S.parseOrThrow(S.string),
   }
 }
 
@@ -838,7 +842,7 @@ type options = {
   url: string,
   chain: ChainMap.Chain.t,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
-  allEventSignatures: array<string>,
+  allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
   lowercaseAddresses: bool,
   ws?: string,
 }
@@ -850,7 +854,7 @@ let make = (
     url,
     chain,
     eventRouter,
-    allEventSignatures,
+    allEventParams,
     lowercaseAddresses,
     ?ws,
   }: options,
@@ -993,12 +997,16 @@ let make = (
     {log: hyperSyncLog}
   }
 
-  let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
+  let hscDecoder: ref<option<HyperSyncClient.Decoder.tWithParams>> = ref(None)
   let getHscDecoder = () => {
     switch hscDecoder.contents {
     | Some(decoder) => decoder
     | None => {
-        let decoder = HyperSyncClient.Decoder.fromSignatures(allEventSignatures)
+        let decoder = HyperSyncClient.Decoder.fromParams(
+          allEventParams,
+          ~checksumAddresses=!lowercaseAddresses,
+        )
+        hscDecoder := Some(decoder)
         decoder
       }
     }
@@ -1071,7 +1079,7 @@ let make = (
     // We also don't care about it when we have a hard max block interval
     if (
       executedBlockInterval >= suggestedBlockInterval &&
-        !(mutSuggestedBlockIntervals->Utils.Dict.has(maxSuggestedBlockIntervalKey))
+        !(mutSuggestedBlockIntervals->Dict.has(maxSuggestedBlockIntervalKey))
     ) {
       // Increase batch size going forward, but do not increase past a configured maximum
       // See: https://en.wikipedia.org/wiki/Additive_increase/multiplicative_decrease
@@ -1088,7 +1096,7 @@ let make = (
     let hyperSyncEvents = logs->Belt.Array.map(convertLogToHyperSyncEvent)
 
     // Decode using HyperSyncClient decoder
-    let parsedEvents = try await getHscDecoder().decodeEvents(hyperSyncEvents) catch {
+    let parsedEvents = try await getHscDecoder().decodeLogs(hyperSyncEvents) catch {
     | exn =>
       throw(
         Source.GetItemsError(
@@ -1107,7 +1115,7 @@ let make = (
     ->Array.zip(parsedEvents)
     ->Array.filterMap(((
       log: Rpc.GetLogs.log,
-      maybeDecodedEvent: Nullable.t<HyperSyncClient.Decoder.decodedEvent>,
+      maybeDecodedEvent: Nullable.t<Internal.eventParams>,
     )) => {
       let topic0 = log.topics[0]->Option.getOr("0x0")
       let routedAddress = if lowercaseAddresses {
@@ -1158,7 +1166,7 @@ let make = (
                     contractName: eventConfig.contractName,
                     eventName: eventConfig.name,
                     chainId: chain->ChainMap.Chain.toChainId,
-                    params: decoded->eventConfig.convertHyperSyncEventArgs,
+                    params: decoded,
                     transaction,
                     block,
                     srcAddress: routedAddress,
@@ -1178,16 +1186,27 @@ let make = (
 
     let totalTimeElapsed = startFetchingBatchTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
-    let reorgGuard: ReorgDetection.reorgGuard = {
-      prevRangeLastBlock: optFirstBlockParent->Option.map(b => {
-        ReorgDetection.blockNumber: b.number,
-        blockHash: b.hash,
-      }),
-      rangeLastBlock: {
-        blockNumber: latestFetchedBlockInfo.number,
-        blockHash: latestFetchedBlockInfo.hash,
-      },
+    // Every fetched block carries `hash` and `parentHash`, so each one yields
+    // two confirmed (number, hash) pairs for reorg detection at no extra cost.
+    let blockHashes = []
+    let pushBlockInfo = (b: blockInfo) => {
+      blockHashes->Array.push({ReorgDetection.blockNumber: b.number, blockHash: b.hash})->ignore
+      if b.number > 0 {
+        blockHashes
+        ->Array.push({ReorgDetection.blockNumber: b.number - 1, blockHash: b.parentHash})
+        ->ignore
+      }
+    }
+    pushBlockInfo(latestFetchedBlockInfo)
+    switch optFirstBlockParent {
+    | Some(b) => pushBlockInfo(b)
+    | None => ()
     }
+    logs->Belt.Array.forEach(log =>
+      blockHashes
+      ->Array.push({ReorgDetection.blockNumber: log.blockNumber, blockHash: log.blockHash})
+      ->ignore
+    )
 
     {
       latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
@@ -1197,19 +1216,20 @@ let make = (
         totalTimeElapsed: totalTimeElapsed,
       },
       knownHeight,
-      reorgGuard,
+      blockHashes,
       fromBlockQueried: fromBlock,
     }
   }
 
-  let getBlockHashes = (~blockNumbers, ~logger as _currentlyUnusedLogger) => {
-    // Clear cache by creating a fresh LazyLoader
-    // This is important, since we call this
-    // function when a reorg is detected
+  let onReorg = (~rollbackTargetBlock as _) => {
+    // Drop cached block/transaction/receipt data — after a reorg the cached
+    // entries may refer to orphaned-chain values.
     blockLoader := makeBlockLoader()
     transactionLoader := makeTransactionLoader()
     receiptLoader := makeReceiptLoader()
+  }
 
+  let getBlockHashes = (~blockNumbers, ~logger as _currentlyUnusedLogger) => {
     blockNumbers
     ->Array.map(blockNum => blockLoader.contents->LazyLoader.get(blockNum))
     ->Promise.all
@@ -1243,6 +1263,7 @@ let make = (
     poweredByHyperSync: false,
     pollingInterval: syncConfig.pollingInterval,
     getBlockHashes,
+    onReorg,
     getHeightOrThrow: async () => {
       let timerRef = Hrtime.makeTimer()
       let height = try {

package/src/sources/RpcSource.res.mjs

@@ -43,7 +43,8 @@ function parseBlockInfo(json) {
   return {
     number: S$RescriptSchema.parseOrThrow(json["number"], Rpc.hexIntSchema),
     timestamp: S$RescriptSchema.parseOrThrow(json["timestamp"], Rpc.hexIntSchema),
-    hash: S$RescriptSchema.parseOrThrow(json["hash"], S$RescriptSchema.string)
+    hash: S$RescriptSchema.parseOrThrow(json["hash"], S$RescriptSchema.string),
+    parentHash: S$RescriptSchema.parseOrThrow(json["parentHash"], S$RescriptSchema.string)
   };
 }
 
@@ -917,7 +918,7 @@ function makeThrowingGetEventTransaction(getTransactionJson, getReceiptJson, low
 
 function make(param) {
   let lowercaseAddresses = param.lowercaseAddresses;
-  let allEventSignatures = param.allEventSignatures;
+  let allEventParams = param.allEventParams;
   let eventRouter = param.eventRouter;
   let chain = param.chain;
   let url = param.url;
@@ -1021,9 +1022,10 @@ function make(param) {
     let decoder = hscDecoder.contents;
     if (decoder !== undefined) {
       return decoder;
-    } else {
-      return HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
     }
+    let decoder$1 = HyperSyncClient.Decoder.fromParams(allEventParams, !lowercaseAddresses);
+    hscDecoder.contents = decoder$1;
+    return decoder$1;
   };
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, partitionId, selection, param, param$1) => {
     let startFetchingBatchTimeRef = Hrtime.makeTimer();
@@ -1038,13 +1040,13 @@ function make(param) {
     let latestFetchedBlockInfo = match$2.latestFetchedBlockInfo;
     let logs = match$2.logs;
     let executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
-    if (executedBlockInterval >= suggestedBlockInterval && !Utils.Dict.has(mutSuggestedBlockIntervals, maxSuggestedBlockIntervalKey)) {
+    if (executedBlockInterval >= suggestedBlockInterval && !(maxSuggestedBlockIntervalKey in mutSuggestedBlockIntervals)) {
       mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
     }
     let hyperSyncEvents = Belt_Array.map(logs, convertLogToHyperSyncEvent);
     let parsedEvents;
     try {
-      parsedEvents = await getHscDecoder().decodeEvents(hyperSyncEvents);
+      parsedEvents = await getHscDecoder().decodeLogs(hyperSyncEvents);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
@@ -1100,7 +1102,7 @@ function make(param) {
             event: {
               contractName: eventConfig.contractName,
               eventName: eventConfig.name,
-              params: eventConfig.convertHyperSyncEventArgs(maybeDecodedEvent),
+              params: maybeDecodedEvent,
               chainId: chain,
               srcAddress: routedAddress,
               logIndex: log.logIndex,
@@ -1113,21 +1115,33 @@ function make(param) {
     }));
     let optFirstBlockParent = await firstBlockParentPromise;
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
-    let reorgGuard_rangeLastBlock = {
-      blockHash: latestFetchedBlockInfo.hash,
-      blockNumber: latestFetchedBlockInfo.number
-    };
-    let reorgGuard_prevRangeLastBlock = Stdlib_Option.map(optFirstBlockParent, b => ({
-      blockHash: b.hash,
-      blockNumber: b.number
-    }));
-    let reorgGuard = {
-      rangeLastBlock: reorgGuard_rangeLastBlock,
-      prevRangeLastBlock: reorgGuard_prevRangeLastBlock
+    let blockHashes = [];
+    let pushBlockInfo = b => {
+      blockHashes.push({
+        blockHash: b.hash,
+        blockNumber: b.number
+      });
+      if (b.number > 0) {
+        blockHashes.push({
+          blockHash: b.parentHash,
+          blockNumber: b.number - 1 | 0
+        });
+        return;
+      }
     };
+    pushBlockInfo(latestFetchedBlockInfo);
+    if (optFirstBlockParent !== undefined) {
+      pushBlockInfo(optFirstBlockParent);
+    }
+    Belt_Array.forEach(logs, log => {
+      blockHashes.push({
+        blockHash: log.blockHash,
+        blockNumber: log.blockNumber
+      });
+    });
     return {
       knownHeight: knownHeight,
-      reorgGuard: reorgGuard,
+      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: latestFetchedBlockInfo.number,
@@ -1137,25 +1151,25 @@ function make(param) {
       }
     };
   };
-  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => {
+  let onReorg = param => {
     blockLoader.contents = makeBlockLoader();
     transactionLoader.contents = makeTransactionLoader();
     receiptLoader.contents = makeReceiptLoader();
-    return Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => ({
-      TAG: "Ok",
-      _0: rawBlocks.map(json => {
-        let b = parseBlockInfo(json);
-        return {
-          blockHash: b.hash,
-          blockNumber: b.number,
-          blockTimestamp: b.timestamp
-        };
-      })
-    })), exn => Promise.resolve({
-      TAG: "Error",
-      _0: exn
-    }));
   };
+  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => ({
+    TAG: "Ok",
+    _0: rawBlocks.map(json => {
+      let b = parseBlockInfo(json);
+      return {
+        blockHash: b.hash,
+        blockNumber: b.number,
+        blockTimestamp: b.timestamp
+      };
+    })
+  })), exn => Promise.resolve({
+    TAG: "Error",
+    _0: exn
+  }));
   let createHeightSubscription = Belt_Option.map(param.ws, wsUrl => (onHeight => RpcWebSocketHeightStream.subscribe(wsUrl, chain, onHeight)));
   return {
     name: name,
@@ -1181,7 +1195,8 @@ function make(param) {
       return height;
     },
     getItemsOrThrow: getItemsOrThrow,
-    createHeightSubscription: createHeightSubscription
+    createHeightSubscription: createHeightSubscription,
+    onReorg: onReorg
   };
 }