envio 2.10.0 → 2.11.1

package/evm.schema.json

@@ -83,7 +83,7 @@
       ]
     },
     "field_selection": {
-      "description": "An object representing additional fields to add to the event passed to handlers.",
+      "description": "Select the block and transaction fields to include in all events globally",
       "anyOf": [
         {
           "$ref": "#/$defs/FieldSelection"
@@ -159,6 +159,17 @@
             "string",
             "null"
           ]
+        },
+        "field_selection": {
+          "description": "Select the block and transaction fields to include in the specific event",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/FieldSelection"
+            },
+            {
+              "type": "null"
+            }
+          ]
         }
       },
       "additionalProperties": false,
@@ -166,6 +177,97 @@
         "event"
       ]
     },
+    "FieldSelection": {
+      "type": "object",
+      "properties": {
+        "transaction_fields": {
+          "description": "The transaction fields to include in the event, or in all events if applied globally",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/TransactionField"
+          }
+        },
+        "block_fields": {
+          "description": "The block fields to include in the event, or in all events if applied globally",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/BlockField"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "TransactionField": {
+      "type": "string",
+      "enum": [
+        "transactionIndex",
+        "hash",
+        "from",
+        "to",
+        "gas",
+        "gasPrice",
+        "maxPriorityFeePerGas",
+        "maxFeePerGas",
+        "cumulativeGasUsed",
+        "effectiveGasPrice",
+        "gasUsed",
+        "input",
+        "nonce",
+        "value",
+        "v",
+        "r",
+        "s",
+        "contractAddress",
+        "logsBloom",
+        "root",
+        "status",
+        "yParity",
+        "chainId",
+        "maxFeePerBlobGas",
+        "blobVersionedHashes",
+        "kind",
+        "l1Fee",
+        "l1GasPrice",
+        "l1GasUsed",
+        "l1FeeScalar",
+        "gasUsedForL1"
+      ]
+    },
+    "BlockField": {
+      "type": "string",
+      "enum": [
+        "parentHash",
+        "nonce",
+        "sha3Uncles",
+        "logsBloom",
+        "transactionsRoot",
+        "stateRoot",
+        "receiptsRoot",
+        "miner",
+        "difficulty",
+        "totalDifficulty",
+        "extraData",
+        "size",
+        "gasLimit",
+        "gasUsed",
+        "uncles",
+        "baseFeePerGas",
+        "blobGasUsed",
+        "excessBlobGas",
+        "parentBeaconBlockRoot",
+        "withdrawalsRoot",
+        "l1BlockNumber",
+        "sendCount",
+        "sendRoot",
+        "mixHash"
+      ]
+    },
     "Network": {
       "type": "object",
       "properties": {
@@ -405,97 +507,6 @@
         "viem",
         "hypersync-client"
       ]
-    },
-    "FieldSelection": {
-      "type": "object",
-      "properties": {
-        "transaction_fields": {
-          "description": "Fields of a transaction to add to the event passed to handlers",
-          "type": [
-            "array",
-            "null"
-          ],
-          "items": {
-            "$ref": "#/$defs/TransactionField"
-          }
-        },
-        "block_fields": {
-          "description": "Fields of a block to add to the event passed to handlers",
-          "type": [
-            "array",
-            "null"
-          ],
-          "items": {
-            "$ref": "#/$defs/BlockField"
-          }
-        }
-      },
-      "additionalProperties": false
-    },
-    "TransactionField": {
-      "type": "string",
-      "enum": [
-        "transactionIndex",
-        "hash",
-        "from",
-        "to",
-        "gas",
-        "gasPrice",
-        "maxPriorityFeePerGas",
-        "maxFeePerGas",
-        "cumulativeGasUsed",
-        "effectiveGasPrice",
-        "gasUsed",
-        "input",
-        "nonce",
-        "value",
-        "v",
-        "r",
-        "s",
-        "contractAddress",
-        "logsBloom",
-        "root",
-        "status",
-        "yParity",
-        "chainId",
-        "maxFeePerBlobGas",
-        "blobVersionedHashes",
-        "kind",
-        "l1Fee",
-        "l1GasPrice",
-        "l1GasUsed",
-        "l1FeeScalar",
-        "gasUsedForL1"
-      ]
-    },
-    "BlockField": {
-      "type": "string",
-      "enum": [
-        "parentHash",
-        "nonce",
-        "sha3Uncles",
-        "logsBloom",
-        "transactionsRoot",
-        "stateRoot",
-        "receiptsRoot",
-        "miner",
-        "difficulty",
-        "totalDifficulty",
-        "extraData",
-        "size",
-        "gasLimit",
-        "gasUsed",
-        "uncles",
-        "baseFeePerGas",
-        "blobGasUsed",
-        "excessBlobGas",
-        "parentBeaconBlockRoot",
-        "withdrawalsRoot",
-        "l1BlockNumber",
-        "sendCount",
-        "sendRoot",
-        "mixHash"
-      ]
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.10.0",
+  "version": "v2.11.1",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,10 +23,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.10.0",
-    "envio-linux-arm64": "v2.10.0",
-    "envio-darwin-x64": "v2.10.0",
-    "envio-darwin-arm64": "v2.10.0"
+    "envio-linux-x64": "v2.11.1",
+    "envio-linux-arm64": "v2.11.1",
+    "envio-darwin-x64": "v2.11.1",
+    "envio-darwin-arm64": "v2.11.1"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.2",

package/src/Internal.gen.ts

@@ -0,0 +1,47 @@
+/* TypeScript file generated from Internal.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import type {t as Address_t} from './Address.gen';
+
+export type genericEvent<params,block,transaction> = {
+  readonly params: params; 
+  readonly chainId: number; 
+  readonly srcAddress: Address_t; 
+  readonly logIndex: number; 
+  readonly transaction: transaction; 
+  readonly block: block
+};
+
+export type genericLoaderArgs<event,context> = { readonly event: event; readonly context: context };
+
+export type genericLoader<args,loaderReturn> = (_1:args) => Promise<loaderReturn>;
+
+export type genericContractRegisterArgs<event,context> = { readonly event: event; readonly context: context };
+
+export type genericContractRegister<args> = (_1:args) => void;
+
+export type genericHandlerArgs<event,context,loaderReturn> = {
+  readonly event: event; 
+  readonly context: context; 
+  readonly loaderReturn: loaderReturn
+};
+
+export type genericHandler<args> = (_1:args) => Promise<void>;
+
+export type genericHandlerWithLoader<loader,handler,eventFilters> = {
+  readonly loader: loader; 
+  readonly handler: handler; 
+  readonly wildcard?: boolean; 
+  readonly eventFilters?: eventFilters; 
+  readonly preRegisterDynamicContracts?: boolean
+};
+
+export type fuelSupplyParams = { readonly subId: string; readonly amount: bigint };
+
+export type fuelTransferParams = {
+  readonly to: Address_t; 
+  readonly assetId: string; 
+  readonly amount: bigint
+};

package/src/Internal.res

@@ -0,0 +1,124 @@
+type eventParams
+type eventBlock
+type eventTransaction
+
+@genType
+type genericEvent<'params, 'block, 'transaction> = {
+  params: 'params,
+  chainId: int,
+  srcAddress: Address.t,
+  logIndex: int,
+  transaction: 'transaction,
+  block: 'block,
+}
+
+type event = genericEvent<eventParams, eventBlock, eventTransaction>
+
+external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
+
+type loaderReturn
+
+@genType
+type genericLoaderArgs<'event, 'context> = {
+  event: 'event,
+  context: 'context,
+}
+@genType
+type genericLoader<'args, 'loaderReturn> = 'args => promise<'loaderReturn>
+
+type loaderContext
+type loaderArgs = genericLoaderArgs<event, loaderContext>
+type loader = genericLoader<loaderArgs, loaderReturn>
+
+@genType
+type genericContractRegisterArgs<'event, 'context> = {
+  event: 'event,
+  context: 'context,
+}
+@genType
+type genericContractRegister<'args> = 'args => unit
+
+type contractRegisterContext
+type contractRegisterArgs = genericContractRegisterArgs<event, contractRegisterContext>
+type contractRegister = genericContractRegister<contractRegisterArgs>
+
+@genType
+type genericHandlerArgs<'event, 'context, 'loaderReturn> = {
+  event: 'event,
+  context: 'context,
+  loaderReturn: 'loaderReturn,
+}
+@genType
+type genericHandler<'args> = 'args => promise<unit>
+
+type handlerContext
+type handlerArgs = genericHandlerArgs<event, handlerContext, loaderReturn>
+type handler = genericHandler<handlerArgs>
+
+@genType
+type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
+  loader: 'loader,
+  handler: 'handler,
+  wildcard?: bool,
+  eventFilters?: 'eventFilters,
+  preRegisterDynamicContracts?: bool,
+}
+
+type eventItem = {
+  eventName: string,
+  contractName: string,
+  loader: option<loader>,
+  handler: option<handler>,
+  contractRegister: option<contractRegister>,
+  timestamp: int,
+  chain: ChainMap.Chain.t,
+  blockNumber: int,
+  logIndex: int,
+  event: event,
+  paramsRawEventSchema: S.schema<eventParams>,
+  //Default to false, if an event needs to
+  //be reprocessed after it has loaded dynamic contracts
+  //This gets set to true and does not try and reload events
+  hasRegisteredDynamicContracts?: bool,
+}
+
+type fuelEventKind =
+  | LogData({logId: string, decode: string => eventParams})
+  | Mint
+  | Burn
+  | Transfer
+  | Call
+type fuelEventConfig = {
+  name: string,
+  kind: fuelEventKind,
+  isWildcard: bool,
+  loader: option<loader>,
+  handler: option<handler>,
+  contractRegister: option<contractRegister>,
+  paramsRawEventSchema: S.schema<eventParams>,
+}
+type fuelContractConfig = {
+  name: string,
+  events: array<fuelEventConfig>,
+}
+
+@genType
+type fuelSupplyParams = {
+  subId: string,
+  amount: bigint,
+}
+let fuelSupplyParamsSchema = S.schema(s => {
+  subId: s.matches(S.string),
+  amount: s.matches(BigInt.schema),
+})
+@genType
+type fuelTransferParams = {
+  to: Address.t,
+  assetId: string,
+  amount: bigint,
+}
+let fuelTransferParamsSchema = S.schema(s => {
+  to: s.matches(Address.schema),
+  assetId: s.matches(S.string),
+  amount: s.matches(BigInt.schema),
+})

package/src/ReorgDetection.res

@@ -0,0 +1,432 @@
+type blockNumberAndHash = {
+  //Block hash is used for actual comparison to test for reorg
+  blockHash: string,
+  blockNumber: int,
+}
+
+type blockData = {
+  ...blockNumberAndHash,
+  //Timestamp is needed for multichain to action reorgs across chains from given blocks to
+  //ensure ordering is kept constant
+  blockTimestamp: int,
+}
+
+module LastBlockScannedHashes: {
+  type t
+  /**Instantiat t with existing data*/
+  let makeWithData: (array<blockData>, ~confirmedBlockThreshold: int) => t
+
+  /**Instantiat empty t with no block data*/
+  let empty: (~confirmedBlockThreshold: int) => t
+
+  /**Add the latest scanned block data to t*/
+  let addLatestLastBlockData: (t, ~lastBlockScannedData: blockData) => t
+
+  /**Read the latest last block scanned data at the from the front of the queue*/
+  let getLatestLastBlockData: t => option<blockData>
+  /** Given the head block number, find the earliest timestamp from the data where the data
+      is still within the given block threshold from the head
+  */
+  let getEarlistTimestampInThreshold: (~currentHeight: int, t) => option<int>
+
+  /**
+  Prunes the back of the unneeded data on the queue.
+
+  In the case of a multichain indexer, pass in the earliest needed timestamp that
+  occurs within the chains threshold. Ensure that we keep track of one range before that
+  as this is that could be the target range block for a reorg
+  */
+  let pruneStaleBlockData: (
+    ~currentHeight: int,
+    ~earliestMultiChainTimestampInThreshold: int=?,
+    t,
+  ) => t
+
+  /**
+  Return a BlockNumbersAndHashes.t rolled back to where hashes
+  match the provided blockNumberAndHashes
+  */
+  let rollBackToValidHash: (t, ~blockNumbersAndHashes: array<blockData>) => result<t, exn>
+
+  /**
+  A record that holds the current height of a chain and the lastBlockScannedHashes,
+  used for passing into getEarliestMultiChainTimestampInThreshold where these values 
+  need to be zipped
+  */
+  type currentHeightAndLastBlockHashes = {
+    currentHeight: int,
+    lastBlockScannedHashes: t,
+  }
+
+  /**
+  Finds the earliest timestamp that is withtin the confirmedBlockThreshold of
+  each chain in a multi chain indexer. Returns None if its a single chain or if
+  the list is empty
+  */
+  let getEarliestMultiChainTimestampInThreshold: array<currentHeightAndLastBlockHashes> => option<
+    int,
+  >
+
+  let getAllBlockNumbers: t => Belt.Array.t<int>
+
+  let hasReorgOccurred: (t, ~firstBlockParentNumberAndHash: option<blockNumberAndHash>) => bool
+
+  /**
+  Return a BlockNumbersAndHashes.t rolled back to where blockData is less
+  than the provided blockNumber
+  */
+  let rollBackToBlockNumberLt: (~blockNumber: int, t) => t
+} = {
+  type t = {
+    // Number of blocks behind head, we want to keep track
+    // as a threshold for reorgs. If for eg. this is 200,
+    // it means we are accounting for reorgs up to 200 blocks
+    // behind the head
+    confirmedBlockThreshold: int,
+    // A cached list of recent blockdata to make comparison checks
+    // for reorgs. Should be quite short data set
+    // so using built in array for data structure.
+    lastBlockScannedDataList: list<blockData>,
+  }
+
+  //Instantiates LastBlockHashes.t
+  let makeWithDataInternal = (lastBlockScannedDataList, ~confirmedBlockThreshold) => {
+    confirmedBlockThreshold,
+    lastBlockScannedDataList,
+  }
+
+  let makeWithData = (lastBlockScannedDataListArr, ~confirmedBlockThreshold) =>
+    lastBlockScannedDataListArr
+    ->Belt.List.fromArray
+    ->Belt.List.reverse
+    ->makeWithDataInternal(~confirmedBlockThreshold)
+  //Instantiates empty LastBlockHashes
+  let empty = (~confirmedBlockThreshold) => makeWithDataInternal(list{}, ~confirmedBlockThreshold)
+
+  /** Given the head block number, find the earliest timestamp from the data where the data
+      is still within the given block threshold from the head
+  */
+  let rec getEarlistTimestampInThresholdInternal = (
+    // The current block number at the head of the chain
+    ~currentHeight,
+    ~confirmedBlockThreshold,
+    //reversed so that head to tail is earlist to latest
+    reversedLastBlockDataList: list<blockData>,
+  ): option<int> => {
+    switch reversedLastBlockDataList {
+    | list{lastBlockScannedData, ...tail} =>
+      // If the blocknumber is not in the threshold recurse with given blockdata's
+      // timestamp , incrementing the from index
+      if lastBlockScannedData.blockNumber >= currentHeight - confirmedBlockThreshold {
+        // If it's in the threshold return the last earliest timestamp
+        Some(lastBlockScannedData.blockTimestamp)
+      } else {
+        tail->getEarlistTimestampInThresholdInternal(~currentHeight, ~confirmedBlockThreshold)
+      }
+    | list{} => None
+    }
+  }
+
+  let getEarlistTimestampInThreshold = (
+    ~currentHeight,
+    {lastBlockScannedDataList, confirmedBlockThreshold}: t,
+  ) =>
+    lastBlockScannedDataList
+    ->Belt.List.reverse
+    ->getEarlistTimestampInThresholdInternal(~currentHeight, ~confirmedBlockThreshold)
+
+  /**
+  Inserts last scanned blockData in its positional order of blockNumber. Adds would usually
+  be always appending to the head with a new last scanned blockData but could be earlier in the
+  case of a dynamic contract.
+  */
+  let rec addLatestLastBlockDataInternal = (
+    ~lastBlockScannedData,
+    //Default empty, accumRev would be each item part of lastBlockScannedDataList that has
+    //a higher blockNumber than lastBlockScannedData
+    ~accumRev=list{},
+    lastBlockScannedDataList,
+  ) => {
+    switch lastBlockScannedDataList {
+    | list{head, ...tail} =>
+      if head.blockNumber <= lastBlockScannedData.blockNumber {
+        Belt.List.reverseConcat(accumRev, list{lastBlockScannedData, ...lastBlockScannedDataList})
+      } else {
+        tail->addLatestLastBlockDataInternal(
+          ~lastBlockScannedData,
+          ~accumRev=list{head, ...accumRev},
+        )
+      }
+    | list{} => Belt.List.reverseConcat(accumRev, list{lastBlockScannedData})
+    }
+  }
+
+  // Adds the latest blockData to the head of the list
+  let addLatestLastBlockData = (
+    {confirmedBlockThreshold, lastBlockScannedDataList}: t,
+    ~lastBlockScannedData,
+  ) =>
+    lastBlockScannedDataList
+    ->addLatestLastBlockDataInternal(~lastBlockScannedData)
+    ->makeWithDataInternal(~confirmedBlockThreshold)
+
+  let getLatestLastBlockData = (self: t) => self.lastBlockScannedDataList->Belt.List.head
+
+  let blockDataIsPastThreshold = (
+    lastBlockScannedData: blockData,
+    ~currentHeight: int,
+    ~confirmedBlockThreshold: int,
+  ) => lastBlockScannedData.blockNumber < currentHeight - confirmedBlockThreshold
+
+  type rec trampoline<'a> = Data('a) | Callback(unit => trampoline<'a>)
+
+  /**
+    Trampolines are a method of handling mutual recursions without the risk of hitting stack limits
+
+    Tail Call Optimization is not possible on mutually recursive functions and so this is a manual optizimation
+
+    (note: this implementation of "trampoline" uses a tail call and so TCO tranfsorms it to a while loop in JS)
+  */
+  let rec trampoline = value =>
+    switch value {
+    | Data(v) => v
+    | Callback(fn) => fn()->trampoline
+    }
+
+  //Prunes the back of the unneeded data on the queue
+  let rec pruneStaleBlockDataInternal = (
+    ~currentHeight,
+    ~earliestMultiChainTimestampInThreshold,
+    ~confirmedBlockThreshold,
+    lastBlockScannedDataListReversed: list<blockData>,
+  ) => {
+    switch earliestMultiChainTimestampInThreshold {
+    // If there is no "earlist multichain timestamp in threshold"
+    // simply prune the earliest block in the case that the block is
+    // outside of the confirmedBlockThreshold
+    | None =>
+      Callback(
+        () =>
+          lastBlockScannedDataListReversed->pruneEarliestBlockData(
+            ~currentHeight,
+            ~earliestMultiChainTimestampInThreshold,
+            ~confirmedBlockThreshold,
+          ),
+      )
+    | Some(timestampThresholdNeeded) =>
+      switch lastBlockScannedDataListReversed {
+      | list{_head, second, ..._tail} =>
+        // Ony prune in the case where the second lastBlockScannedData from the back
+        // Has an earlier timestamp than the timestampThresholdNeeded (this is
+        // the earliest timestamp across all chains where the lastBlockScannedData is
+        // still within the confirmedBlockThreshold)
+        if second.blockTimestamp < timestampThresholdNeeded {
+          Callback(
+            () =>
+              lastBlockScannedDataListReversed->pruneEarliestBlockData(
+                ~currentHeight,
+                ~earliestMultiChainTimestampInThreshold,
+                ~confirmedBlockThreshold,
+              ),
+          )
+        } else {
+          Data(lastBlockScannedDataListReversed)
+        }
+      | list{_} | list{} => Data(lastBlockScannedDataListReversed)
+      }
+    }
+  }
+  and pruneEarliestBlockData = (
+    lastBlockScannedDataListReversed: list<blockData>,
+    ~currentHeight,
+    ~earliestMultiChainTimestampInThreshold,
+    ~confirmedBlockThreshold,
+  ) => {
+    switch lastBlockScannedDataListReversed {
+    | list{earliestLastBlockData, ...tail} =>
+      // In the case that back is past the threshold, remove it and
+      // recurse
+      if earliestLastBlockData->blockDataIsPastThreshold(~currentHeight, ~confirmedBlockThreshold) {
+        // Recurse to check the next item
+        Callback(
+          () =>
+            tail->pruneStaleBlockDataInternal(
+              ~currentHeight,
+              ~earliestMultiChainTimestampInThreshold,
+              ~confirmedBlockThreshold,
+            ),
+        )
+      } else {
+        Data(lastBlockScannedDataListReversed)
+      }
+    | list{} => Data(list{})
+    }
+  }
+
+  //Prunes the back of the unneeded data on the queue
+  let pruneStaleBlockData = (
+    ~currentHeight,
+    ~earliestMultiChainTimestampInThreshold=?,
+    {confirmedBlockThreshold, lastBlockScannedDataList}: t,
+  ) => {
+    trampoline(
+      lastBlockScannedDataList
+      ->Belt.List.reverse
+      ->pruneStaleBlockDataInternal(
+        ~confirmedBlockThreshold,
+        ~currentHeight,
+        ~earliestMultiChainTimestampInThreshold,
+      ),
+    )
+    ->Belt.List.reverse
+    ->makeWithDataInternal(~confirmedBlockThreshold)
+  }
+
+  type blockNumberToHashMap = Belt.Map.Int.t<string>
+  exception BlockNotIncludedInMap(int)
+
+  let doBlockHashesMatch = (lastBlockScannedData, ~latestBlockHashes: blockNumberToHashMap) => {
+    let {blockNumber, blockHash} = lastBlockScannedData
+    let matchingBlock = latestBlockHashes->Belt.Map.Int.get(blockNumber)
+
+    switch matchingBlock {
+    | None => Error(BlockNotIncludedInMap(blockNumber))
+    | Some(latestBlockHash) => Ok(blockHash == latestBlockHash)
+    }
+  }
+
+  let rec rollBackToValidHashInternal = (
+    latestBlockScannedData: list<blockData>,
+    ~latestBlockHashes: blockNumberToHashMap,
+  ) => {
+    switch latestBlockScannedData {
+    | list{} => Ok(list{}) //Nothing on the front to rollback to
+    | list{lastBlockScannedData, ...tail} =>
+      lastBlockScannedData
+      ->doBlockHashesMatch(~latestBlockHashes)
+      ->Belt.Result.flatMap(blockHashesDoMatch => {
+        if blockHashesDoMatch {
+          Ok(list{lastBlockScannedData, ...tail})
+        } else {
+          tail->rollBackToValidHashInternal(~latestBlockHashes)
+        }
+      })
+    }
+  }
+
+  /**
+  Return a BlockNumbersAndHashes.t rolled back to where hashes
+  match the provided blockNumberAndHashes
+  */
+  let rollBackToValidHash = (self: t, ~blockNumbersAndHashes: array<blockData>) => {
+    let {confirmedBlockThreshold, lastBlockScannedDataList} = self
+    let latestBlockHashes =
+      blockNumbersAndHashes
+      ->Belt.Array.map(({blockNumber, blockHash}) => (blockNumber, blockHash))
+      ->Belt.Map.Int.fromArray
+
+    lastBlockScannedDataList
+    ->rollBackToValidHashInternal(~latestBlockHashes)
+    ->Belt.Result.map(list => list->makeWithDataInternal(~confirmedBlockThreshold))
+  }
+
+  let min = (arrInt: array<int>) => {
+    arrInt->Belt.Array.reduce(None, (current, val) => {
+      switch current {
+      | None => Some(val)
+      | Some(current) => Js.Math.min_int(current, val)->Some
+      }
+    })
+  }
+
+  let rec rollBackToBlockNumberLtInternal = (
+    ~blockNumber: int,
+    latestBlockScannedData: list<blockData>,
+  ) => {
+    switch latestBlockScannedData {
+    | list{} => list{}
+    | list{head, ...tail} =>
+      if head.blockNumber < blockNumber {
+        latestBlockScannedData
+      } else {
+        tail->rollBackToBlockNumberLtInternal(~blockNumber)
+      }
+    }
+  }
+
+  /**
+  Return a BlockNumbersAndHashes.t rolled back to where blockData is less
+  than the provided blockNumber
+  */
+  let rollBackToBlockNumberLt = (~blockNumber: int, self: t) => {
+    let {confirmedBlockThreshold, lastBlockScannedDataList} = self
+    lastBlockScannedDataList
+    ->rollBackToBlockNumberLtInternal(~blockNumber)
+    ->makeWithDataInternal(~confirmedBlockThreshold)
+  }
+
+  type currentHeightAndLastBlockHashes = {
+    currentHeight: int,
+    lastBlockScannedHashes: t,
+  }
+
+  /**
+  Find the the earliest block time across multiple instances of self where the block timestamp
+  falls within its own confirmed block threshold
+
+  Return None if there is only one chain (since we don't want to take this val into account for a
+  single chain indexer) or if there are no chains (should never be the case)
+  */
+  let getEarliestMultiChainTimestampInThreshold = (
+    multiSelf: array<currentHeightAndLastBlockHashes>,
+  ) => {
+    switch multiSelf {
+    | [_singleVal] =>
+      //In the case where there is only one chain, return none as there would be no need to aggregate
+      //or keep track of the lowest timestamp. The chain can purge as far back as its confirmed block range
+      None
+    | multiSelf =>
+      multiSelf
+      ->Belt.Array.keepMap(({currentHeight, lastBlockScannedHashes}) => {
+        lastBlockScannedHashes->getEarlistTimestampInThreshold(~currentHeight)
+      })
+      ->min
+    }
+  }
+
+  let getAllBlockNumbers = (self: t) =>
+    self.lastBlockScannedDataList->Belt.List.reduceReverse([], (acc, v) => {
+      Belt.Array.concat(acc, [v.blockNumber])
+    })
+
+  /**
+  Checks whether reorg has occured by comparing the parent hash with the last saved block hash.
+  */
+  let rec hasReorgOccurredInternal = (
+    lastBlockScannedDataList,
+    ~firstBlockParentNumberAndHash: option<blockNumberAndHash>,
+  ) => {
+    switch (firstBlockParentNumberAndHash, lastBlockScannedDataList) {
+    | (Some({blockHash: parentHash, blockNumber: parentBlockNumber}), list{head, ...tail}) =>
+      if parentBlockNumber == head.blockNumber {
+        parentHash != head.blockHash
+      } else {
+        //if block numbers do not match, this is a dynamic contract case and should recurse
+        //through the list to look for a matching block or nothing to validate
+        tail->hasReorgOccurredInternal(~firstBlockParentNumberAndHash)
+      }
+    | _ => //If parentHash is None, either it's the genesis block (no reorg)
+      //Or its already confirmed so no Reorg
+      //If recentLastBlockData is None, we have not yet saved blockData to compare against
+      false
+    }
+  }
+
+  let hasReorgOccurred = (
+    lastBlockScannedHashes: t,
+    ~firstBlockParentNumberAndHash: option<blockNumberAndHash>,
+  ) =>
+    lastBlockScannedHashes.lastBlockScannedDataList->hasReorgOccurredInternal(
+      ~firstBlockParentNumberAndHash,
+    )
+}

package/src/sources/HyperSyncJsonApi.res

@@ -0,0 +1,376 @@
+type unchecksummedEthAddress = string
+
+module QueryTypes = {
+  type blockFieldOptions =
+    | @as("number") Number
+    | @as("hash") Hash
+    | @as("parent_hash") ParentHash
+    | @as("nonce") Nonce
+    | @as("sha3_uncles") Sha3Uncles
+    | @as("logs_bloom") LogsBloom
+    | @as("transactions_root") TransactionsRoot
+    | @as("state_root") StateRoot
+    | @as("receipts_root") ReceiptsRoot
+    | @as("miner") Miner
+    | @as("difficulty") Difficulty
+    | @as("total_difficulty") TotalDifficulty
+    | @as("extra_data") ExtraData
+    | @as("size") Size
+    | @as("gas_limit") GasLimit
+    | @as("gas_used") GasUsed
+    | @as("timestamp") Timestamp
+    | @as("uncles") Uncles
+    | @as("base_fee_per_gas") BaseFeePerGas
+
+  let blockFieldOptionsSchema = Utils.Schema.enum([
+    Number,
+    Hash,
+    ParentHash,
+    Nonce,
+    Sha3Uncles,
+    LogsBloom,
+    TransactionsRoot,
+    StateRoot,
+    ReceiptsRoot,
+    Miner,
+    Difficulty,
+    TotalDifficulty,
+    ExtraData,
+    Size,
+    GasLimit,
+    GasUsed,
+    Timestamp,
+    Uncles,
+    BaseFeePerGas,
+  ])
+
+  type blockFieldSelection = array<blockFieldOptions>
+
+  let blockFieldSelectionSchema = S.array(blockFieldOptionsSchema)
+
+  type transactionFieldOptions =
+    | @as("block_hash") BlockHash
+    | @as("block_number") BlockNumber
+    | @as("from") From
+    | @as("gas") Gas
+    | @as("gas_price") GasPrice
+    | @as("hash") Hash
+    | @as("input") Input
+    | @as("nonce") Nonce
+    | @as("to") To
+    | @as("transaction_index") TransactionIndex
+    | @as("value") Value
+    | @as("v") V
+    | @as("r") R
+    | @as("s") S
+    | @as("max_priority_fee_per_gas") MaxPriorityFeePerGas
+    | @as("max_fee_per_gas") MaxFeePerGas
+    | @as("chain_id") ChainId
+    | @as("cumulative_gas_used") CumulativeGasUsed
+    | @as("effective_gas_price") EffectiveGasPrice
+    | @as("gas_used") GasUsed
+    | @as("contract_address") ContractAddress
+    | @as("logs_bloom") LogsBloom
+    | @as("type") Type
+    | @as("root") Root
+    | @as("status") Status
+    | @as("sighash") Sighash
+
+  let transactionFieldOptionsSchema = Utils.Schema.enum([
+    BlockHash,
+    BlockNumber,
+    From,
+    Gas,
+    GasPrice,
+    Hash,
+    Input,
+    Nonce,
+    To,
+    TransactionIndex,
+    Value,
+    V,
+    R,
+    S,
+    MaxPriorityFeePerGas,
+    MaxFeePerGas,
+    ChainId,
+    CumulativeGasUsed,
+    EffectiveGasPrice,
+    GasUsed,
+    ContractAddress,
+    LogsBloom,
+    Type,
+    Root,
+    Status,
+    Sighash,
+  ])
+
+  type transactionFieldSelection = array<transactionFieldOptions>
+
+  let transactionFieldSelectionSchema = S.array(transactionFieldOptionsSchema)
+
+  type logFieldOptions =
+    | @as("removed") Removed
+    | @as("log_index") LogIndex
+    | @as("transaction_index") TransactionIndex
+    | @as("transaction_hash") TransactionHash
+    | @as("block_hash") BlockHash
+    | @as("block_number") BlockNumber
+    | @as("address") Address
+    | @as("data") Data
+    | @as("topic0") Topic0
+    | @as("topic1") Topic1
+    | @as("topic2") Topic2
+    | @as("topic3") Topic3
+
+  let logFieldOptionsSchema = Utils.Schema.enum([
+    Removed,
+    LogIndex,
+    TransactionIndex,
+    TransactionHash,
+    BlockHash,
+    BlockNumber,
+    Address,
+    Data,
+    Topic0,
+    Topic1,
+    Topic2,
+    Topic3,
+  ])
+
+  type logFieldSelection = array<logFieldOptions>
+
+  let logFieldSelectionSchema = S.array(logFieldOptionsSchema)
+
+  type fieldSelection = {
+    block?: blockFieldSelection,
+    transaction?: transactionFieldSelection,
+    log?: logFieldSelection,
+  }
+
+  let fieldSelectionSchema = S.object(s => {
+    block: ?s.field("block", S.option(blockFieldSelectionSchema)),
+    transaction: ?s.field("transaction", S.option(transactionFieldSelectionSchema)),
+    log: ?s.field("log", S.option(logFieldSelectionSchema)),
+  })
+
+  type logParams = {
+    address?: array<Address.t>,
+    topics: array<array<Ethers.EventFilter.topic>>,
+  }
+
+  let logParamsSchema = S.object(s => {
+    address: ?s.field("address", S.option(S.array(Address.schema))),
+    topics: s.field("topics", S.array(S.array(EvmTypes.Hex.schema))),
+  })
+
+  type transactionParams = {
+    from?: array<Address.t>,
+    to?: array<Address.t>,
+    sighash?: array<string>,
+  }
+
+  let transactionParamsSchema = S.object(s => {
+    from: ?s.field("from", S.option(S.array(Address.schema))),
+    to: ?s.field("to", S.option(S.array(Address.schema))),
+    sighash: ?s.field("sighash", S.option(S.array(S.string))),
+  })
+
+  type postQueryBody = {
+    fromBlock: int,
+    toBlockExclusive?: int,
+    logs?: array<logParams>,
+    transactions?: array<transactionParams>,
+    fieldSelection: fieldSelection,
+    maxNumLogs?: int,
+    includeAllBlocks?: bool,
+  }
+
+  let postQueryBodySchema = S.object(s => {
+    fromBlock: s.field("from_block", S.int),
+    toBlockExclusive: ?s.field("to_block", S.option(S.int)),
+    logs: ?s.field("logs", S.option(S.array(logParamsSchema))),
+    transactions: ?s.field("transactions", S.option(S.array(transactionParamsSchema))),
+    fieldSelection: s.field("field_selection", fieldSelectionSchema),
+    maxNumLogs: ?s.field("max_num_logs", S.option(S.int)),
+    includeAllBlocks: ?s.field("include_all_blocks", S.option(S.bool)),
+  })
+}
+
+module ResponseTypes = {
+  type blockData = {
+    number?: int,
+    hash?: string,
+    parentHash?: string,
+    nonce?: option<int>,
+    sha3Uncles?: string,
+    logsBloom?: string,
+    transactionsRoot?: string,
+    stateRoot?: string,
+    receiptsRoot?: string,
+    miner?: unchecksummedEthAddress,
+    difficulty?: option<bigint>,
+    totalDifficulty?: option<bigint>,
+    extraData?: string,
+    size?: bigint,
+    gasLimit?: bigint,
+    gasUsed?: bigint,
+    timestamp?: bigint,
+    uncles?: option<string>,
+    baseFeePerGas?: option<bigint>,
+  }
+
+  let blockDataSchema = S.object(s => {
+    number: ?s.field("number", S.option(S.int)),
+    hash: ?s.field("hash", S.option(S.string)),
+    parentHash: ?s.field("parent_hash", S.option(S.string)),
+    nonce: ?s.field("nonce", S.option(S.null(S.int))),
+    sha3Uncles: ?s.field("sha3_uncles", S.option(S.string)),
+    logsBloom: ?s.field("logs_bloom", S.option(S.string)),
+    transactionsRoot: ?s.field("transactions_root", S.option(S.string)),
+    stateRoot: ?s.field("state_root", S.option(S.string)),
+    receiptsRoot: ?s.field("receipts_root", S.option(S.string)),
+    miner: ?s.field("miner", S.option(S.string)),
+    difficulty: ?s.field("difficulty", S.option(S.null(BigInt.schema))),
+    totalDifficulty: ?s.field("total_difficulty", S.option(S.null(BigInt.schema))),
+    extraData: ?s.field("extra_data", S.option(S.string)),
+    size: ?s.field("size", S.option(BigInt.schema)),
+    gasLimit: ?s.field("gas_limit", S.option(BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
+    timestamp: ?s.field("timestamp", S.option(BigInt.schema)),
+    uncles: ?s.field("unclus", S.option(S.null(S.string))),
+    baseFeePerGas: ?s.field("base_fee_per_gas", S.option(S.null(BigInt.schema))),
+  })
+
+  type transactionData = {
+    blockHash?: string,
+    blockNumber?: int,
+    from?: option<unchecksummedEthAddress>,
+    gas?: bigint,
+    gasPrice?: option<bigint>,
+    hash?: string,
+    input?: string,
+    nonce?: int,
+    to?: option<unchecksummedEthAddress>,
+    transactionIndex?: int,
+    value?: bigint,
+    v?: option<string>,
+    r?: option<string>,
+    s?: option<string>,
+    maxPriorityFeePerGas?: option<bigint>,
+    maxFeePerGas?: option<bigint>,
+    chainId?: option<int>,
+    cumulativeGasUsed?: bigint,
+    effectiveGasPrice?: bigint,
+    gasUsed?: bigint,
+    contractAddress?: option<unchecksummedEthAddress>,
+    logsBoom?: string,
+    type_?: option<int>,
+    root?: option<string>,
+    status?: option<int>,
+    sighash?: option<string>,
+  }
+
+  let transactionDataSchema = S.object(s => {
+    blockHash: ?s.field("block_hash", S.option(S.string)),
+    blockNumber: ?s.field("block_number", S.option(S.int)),
+    from: ?s.field("from", S.option(S.null(S.string))),
+    gas: ?s.field("gas", S.option(BigInt.schema)),
+    gasPrice: ?s.field("gas_price", S.option(S.null(BigInt.schema))),
+    hash: ?s.field("hash", S.option(S.string)),
+    input: ?s.field("input", S.option(S.string)),
+    nonce: ?s.field("nonce", S.option(S.int)),
+    to: ?s.field("to", S.option(S.null(S.string))),
+    transactionIndex: ?s.field("transaction_index", S.option(S.int)),
+    value: ?s.field("value", S.option(BigInt.schema)),
+    v: ?s.field("v", S.option(S.null(S.string))),
+    r: ?s.field("r", S.option(S.null(S.string))),
+    s: ?s.field("s", S.option(S.null(S.string))),
+    maxPriorityFeePerGas: ?s.field("max_priority_fee_per_gas", S.option(S.null(BigInt.schema))),
+    maxFeePerGas: ?s.field("max_fee_per_gas", S.option(S.null(BigInt.schema))),
+    chainId: ?s.field("chain_id", S.option(S.null(S.int))),
+    cumulativeGasUsed: ?s.field("cumulative_gas_used", S.option(BigInt.schema)),
+    effectiveGasPrice: ?s.field("effective_gas_price", S.option(BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
+    contractAddress: ?s.field("contract_address", S.option(S.null(S.string))),
+    logsBoom: ?s.field("logs_bloom", S.option(S.string)),
+    type_: ?s.field("type", S.option(S.null(S.int))),
+    root: ?s.field("root", S.option(S.null(S.string))),
+    status: ?s.field("status", S.option(S.null(S.int))),
+    sighash: ?s.field("sighash", S.option(S.null(S.string))),
+  })
+
+  type logData = {
+    removed?: option<bool>,
+    index?: int,
+    transactionIndex?: int,
+    transactionHash?: string,
+    blockHash?: string,
+    blockNumber?: int,
+    address?: unchecksummedEthAddress,
+    data?: string,
+    topic0?: option<Ethers.EventFilter.topic>,
+    topic1?: option<Ethers.EventFilter.topic>,
+    topic2?: option<Ethers.EventFilter.topic>,
+    topic3?: option<Ethers.EventFilter.topic>,
+  }
+
+  let logDataSchema = S.object(s => {
+    removed: ?s.field("removed", S.option(S.null(S.bool))),
+    index: ?s.field("log_index", S.option(S.int)),
+    transactionIndex: ?s.field("transaction_index", S.option(S.int)),
+    transactionHash: ?s.field("transaction_hash", S.option(S.string)),
+    blockHash: ?s.field("block_hash", S.option(S.string)),
+    blockNumber: ?s.field("block_number", S.option(S.int)),
+    address: ?s.field("address", S.option(S.string)),
+    data: ?s.field("data", S.option(S.string)),
+    topic0: ?s.field("topic0", S.option(S.null(EvmTypes.Hex.schema))),
+    topic1: ?s.field("topic1", S.option(S.null(EvmTypes.Hex.schema))),
+    topic2: ?s.field("topic2", S.option(S.null(EvmTypes.Hex.schema))),
+    topic3: ?s.field("topic3", S.option(S.null(EvmTypes.Hex.schema))),
+  })
+
+  type data = {
+    blocks?: array<blockData>,
+    transactions?: array<transactionData>,
+    logs?: array<logData>,
+  }
+
+  let dataSchema = S.object(s => {
+    blocks: ?s.field("blocks", S.array(blockDataSchema)->S.option),
+    transactions: ?s.field("transactions", S.array(transactionDataSchema)->S.option),
+    logs: ?s.field("logs", S.array(logDataSchema)->S.option),
+  })
+
+  type queryResponse = {
+    data: array<data>,
+    archiveHeight: int,
+    nextBlock: int,
+    totalTime: int,
+  }
+
+  let queryResponseSchema = S.object(s => {
+    data: s.field("data", S.array(dataSchema)),
+    archiveHeight: s.field("archive_height", S.int),
+    nextBlock: s.field("next_block", S.int),
+    totalTime: s.field("total_execution_time", S.int),
+  })
+}
+
+let queryRoute = Rest.route(() => {
+  path: "/query",
+  method: Post,
+  variables: s => s.body(QueryTypes.postQueryBodySchema),
+  responses: [
+    s => s.data(ResponseTypes.queryResponseSchema),
+  ]
+})
+
+let heightRoute = Rest.route(() => {
+  path: "/height",
+  method: Get,
+  variables: _ => (),
+  responses: [
+    s => s.field("height", S.int),
+  ]
+})