envio 3.0.2 → 3.1.0-rc.0

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
   };
 }
 

package/src/sources/SimulateSource.res

@@ -39,13 +39,7 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
       let reportedHeight = max(endBlock, 1)
       Promise.resolve({
         Source.knownHeight: reportedHeight,
-        reorgGuard: {
-          rangeLastBlock: {
-            blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-            blockNumber: reportedHeight,
-          },
-          prevRangeLastBlock: None,
-        },
+        blockHashes: [],
         parsedQueueItems: result,
         fromBlockQueried: 0,
         latestFetchedBlockNumber: reportedHeight,

package/src/sources/SimulateSource.res.mjs

@@ -22,13 +22,7 @@ function make(items, endBlock, chain) {
       let reportedHeight = Primitive_int.max(endBlock, 1);
       return Promise.resolve({
         knownHeight: reportedHeight,
-        reorgGuard: {
-          rangeLastBlock: {
-            blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-            blockNumber: reportedHeight
-          },
-          prevRangeLastBlock: undefined
-        },
+        blockHashes: [],
         parsedQueueItems: result,
         fromBlockQueried: 0,
         latestFetchedBlockNumber: reportedHeight,

package/src/sources/Source.res

@@ -12,7 +12,11 @@ Thes response returned from a block range fetch
 */
 type blockRangeFetchResponse = {
   knownHeight: int,
-  reorgGuard: ReorgDetection.reorgGuard,
+  // Best-effort (blockNumber, blockHash) pairs observed while fetching this range.
+  // Used by reorg detection; gaps are OK, no extra requests are made to fill them.
+  // Duplicates with the same block number are allowed — registerReorgGuard treats
+  // a within-array hash mismatch on the same block number as a reorg.
+  blockHashes: array<ReorgDetection.blockData>,
   parsedQueueItems: array<Internal.item>,
   fromBlockQueried: int,
   latestFetchedBlockNumber: int,
@@ -58,4 +62,7 @@ type t = {
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,
   createHeightSubscription?: (~onHeight: int => unit) => unit => unit,
+  // Invoked by SourceManager once a rollback target is known so the source can
+  // drop any state that may now point at an orphaned chain (e.g. RPC block cache).
+  onReorg?: (~rollbackTargetBlock: int) => unit,
 }

package/src/sources/SourceManager.res

@@ -36,6 +36,15 @@ type t = {
 
 let getActiveSource = sourceManager => sourceManager.activeSource
 
+let onReorg = (sourceManager: t, ~rollbackTargetBlock) => {
+  sourceManager.sourcesState->Array.forEach(({source}) => {
+    switch source.onReorg {
+    | Some(cb) => cb(~rollbackTargetBlock)
+    | None => ()
+    }
+  })
+}
+
 type sourceRole = Primary | Secondary
 
 // Determines whether a source is Primary or Secondary given the current mode.

package/src/sources/SourceManager.res.mjs

@@ -17,6 +17,15 @@ function getActiveSource(sourceManager) {
   return sourceManager.activeSource;
 }
 
+function onReorg(sourceManager, rollbackTargetBlock) {
+  sourceManager.sourcesState.forEach(param => {
+    let cb = param.source.onReorg;
+    if (cb !== undefined) {
+      return cb(rollbackTargetBlock);
+    }
+  });
+}
+
 function getSourceRole(sourceFor, isRealtime, hasRealtime) {
   if (isRealtime) {
     switch (sourceFor) {
@@ -547,6 +556,7 @@ export {
   getSourceRole,
   make,
   getActiveSource,
+  onReorg,
   fetchNext,
   waitForNewBlock,
   executeQuery,

package/src/sources/SourceManager.resi

@@ -22,6 +22,8 @@ let make: (
 
 let getActiveSource: t => Source.t
 
+let onReorg: (t, ~rollbackTargetBlock: int) => unit
+
 let fetchNext: (
   t,
   ~fetchState: FetchState.t,

package/svm.schema.json

@@ -4,6 +4,10 @@
   "description": "Schema for a YAML config for an envio Svm indexer",
   "type": "object",
   "properties": {
+    "name": {
+      "description": "Name of the project",
+      "type": "string"
+    },
     "description": {
       "description": "Description of the project",
       "type": [
@@ -11,10 +15,6 @@
         "null"
       ]
     },
-    "name": {
-      "description": "Name of the project",
-      "type": "string"
-    },
     "schema": {
       "description": "Custom path to schema.graphql file",
       "type": [
@@ -133,6 +133,13 @@
     "Chain": {
       "type": "object",
       "properties": {
+        "skip": {
+          "description": "Excludes the chain from indexing and migrations. Code generation is unaffected. For testing, prefer using a test framework instead.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
         "rpc": {
           "description": "RPC endpoint URL for connecting to the Svm cluster to fetch blockchain data.",
           "type": "string"