envio 2.12.2 → 2.12.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.12.2",
+  "version": "v2.12.4",
   "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.12.2",
-    "envio-linux-arm64": "v2.12.2",
-    "envio-darwin-x64": "v2.12.2",
-    "envio-darwin-arm64": "v2.12.2"
+    "envio-linux-x64": "v2.12.4",
+    "envio-linux-arm64": "v2.12.4",
+    "envio-darwin-x64": "v2.12.4",
+    "envio-darwin-arm64": "v2.12.4"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",

package/src/ReorgDetection.res

@@ -1,19 +1,39 @@
-type blockNumberAndHash = {
-  //Block hash is used for actual comparison to test for reorg
+open Belt
+
+type blockDataWithTimestamp = {
   blockHash: string,
   blockNumber: int,
+  blockTimestamp: 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,
+  // Block hash is used for actual comparison to test for reorg
+  blockHash: string,
+  blockNumber: int,
 }
 
+external generalizeBlockDataWithTimestamp: blockDataWithTimestamp => blockData = "%identity"
+
 type reorgGuard = {
   lastBlockScannedData: blockData,
-  firstBlockParentNumberAndHash: option<blockNumberAndHash>,
+  firstBlockParentNumberAndHash: option<blockData>,
+}
+
+type reorgDetected = {
+  scannedBlock: blockData,
+  receivedBlock: blockData,
+}
+
+let reorgDetectedToLogParams = (reorgDetected: reorgDetected, ~shouldRollbackOnReorg) => {
+  let {scannedBlock, receivedBlock} = reorgDetected
+  {
+    "msg": `Blockchain reorg detected. ${shouldRollbackOnReorg
+        ? "Initiating indexer rollback"
+        : "NOT initiating indexer rollback due to configuration"}.`,
+    "blockNumber": scannedBlock.blockNumber,
+    "indexedBlockHash": scannedBlock.blockHash,
+    "receivedBlockHash": receivedBlock.blockHash,
+  }
 }
 
 module LastBlockScannedHashes: {
@@ -24,63 +44,28 @@ module LastBlockScannedHashes: {
   /**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
+  /** Registers a new reorg guard, prunes unnened data and returns the updated data 
+   or an error if a reorg has occured 
   */
-  let pruneStaleBlockData: (
-    ~currentHeight: int,
-    ~earliestMultiChainTimestampInThreshold: int=?,
+  let registerReorgGuard: (
     t,
-  ) => t
+    ~reorgGuard: reorgGuard,
+    ~currentBlockHeight: int,
+  ) => result<t, reorgDetected>
 
   /**
-  Return a BlockNumbersAndHashes.t rolled back to where hashes
-  match the provided blockNumberAndHashes
+  Returns the latest block data which matches block number and hashes in the provided array
+  If it doesn't exist in the reorg threshold it returns None or the latest scanned block outside of the reorg threshold
   */
-  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 getLatestValidScannedBlock: (
+    t,
+    ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
+    ~currentBlockHeight: int,
+  ) => option<blockDataWithTimestamp>
 
   let getThresholdBlockNumbers: (t, ~currentBlockHeight: int) => array<int>
 
-  let hasReorgOccurred: (t, ~reorgGuard: reorgGuard) => bool
-
-  /**
-  Return a BlockNumbersAndHashes.t rolled back to where blockData is less
-  than the provided blockNumber
-  */
-  let rollBackToBlockNumberLt: (~blockNumber: int, t) => t
+  let rollbackToValidBlockNumber: (t, ~blockNumber: int) => t
 } = {
   type t = {
     // Number of blocks behind head, we want to keep track
@@ -88,359 +73,194 @@ module LastBlockScannedHashes: {
     // 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>,
+    // A hash map of recent blockdata by block number to make comparison checks
+    // for reorgs.
+    dataByBlockNumber: dict<blockData>,
   }
 
-  //Instantiates LastBlockHashes.t
-  let makeWithDataInternal = (lastBlockScannedDataList, ~confirmedBlockThreshold) => {
-    confirmedBlockThreshold,
-    lastBlockScannedDataList,
-  }
+  let makeWithData = (blocks, ~confirmedBlockThreshold) => {
+    let dataByBlockNumber = Js.Dict.empty()
 
-  let makeWithData = (lastBlockScannedDataListArr, ~confirmedBlockThreshold) =>
-    lastBlockScannedDataListArr
-    ->Belt.List.fromArray
-    ->Belt.List.reverse
-    ->makeWithDataInternal(~confirmedBlockThreshold)
-  //Instantiates empty LastBlockHashes
-  let empty = (~confirmedBlockThreshold) => makeWithDataInternal(list{}, ~confirmedBlockThreshold)
+    blocks->Belt.Array.forEach(block => {
+      dataByBlockNumber->Js.Dict.set(block.blockNumber->Js.Int.toString, block)
+    })
 
-  /** 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
+    {
+      confirmedBlockThreshold,
+      dataByBlockNumber,
     }
   }
+  //Instantiates empty LastBlockHashes
+  let empty = (~confirmedBlockThreshold) => {
+    confirmedBlockThreshold,
+    dataByBlockNumber: Js.Dict.empty(),
+  }
 
-  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,
+  let getDataByBlockNumberCopyInThreshold = (
+    {dataByBlockNumber, confirmedBlockThreshold}: t,
+    ~currentBlockHeight,
   ) => {
-    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},
-        )
+    // Js engine automatically orders numeric object keys
+    let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
+    let thresholdBlockNumber = currentBlockHeight - confirmedBlockThreshold
+
+    let copy = Js.Dict.empty()
+
+    for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
+      let blockNumberKey = ascBlockNumberKeys->Js.Array2.unsafe_get(idx)
+      let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+      let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
+      if isInReorgThreshold {
+        copy->Js.Dict.set(blockNumberKey, scannedBlock)
       }
-    | 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
-    }
+    copy
+  }
 
-  //Prunes the back of the unneeded data on the queue
-  let rec pruneStaleBlockDataInternal = (
-    ~currentHeight,
-    ~earliestMultiChainTimestampInThreshold,
-    ~confirmedBlockThreshold,
-    lastBlockScannedDataListReversed: list<blockData>,
+  let registerReorgGuard = (
+    {confirmedBlockThreshold} as self: t,
+    ~reorgGuard: reorgGuard,
+    ~currentBlockHeight,
   ) => {
-    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)
+    let dataByBlockNumberCopyInThreshold =
+      self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
+
+    let {lastBlockScannedData, firstBlockParentNumberAndHash} = reorgGuard
+
+    let maybeReorgDetected = switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(
+      lastBlockScannedData.blockNumber->Int.toString,
+    ) {
+    | Some(scannedBlock) if scannedBlock.blockHash !== lastBlockScannedData.blockHash =>
+      Some({
+        receivedBlock: lastBlockScannedData,
+        scannedBlock,
+      })
+    | _ =>
+      switch firstBlockParentNumberAndHash {
+      //If parentHash is None, then it's the genesis block (no reorg)
+      //Need to check that parentHash matches because of the dynamic contracts
+      | None => None
+      | Some(firstBlockParentNumberAndHash) =>
+        switch dataByBlockNumberCopyInThreshold->Utils.Dict.dangerouslyGetNonOption(
+          firstBlockParentNumberAndHash.blockNumber->Int.toString,
+        ) {
+        | Some(scannedBlock)
+          if scannedBlock.blockHash !== firstBlockParentNumberAndHash.blockHash =>
+          Some({
+            receivedBlock: firstBlockParentNumberAndHash,
+            scannedBlock,
+          })
+        | _ => None
         }
-      | 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,
-            ),
+
+    switch maybeReorgDetected {
+    | Some(reorgDetected) => Error(reorgDetected)
+    | None => {
+        dataByBlockNumberCopyInThreshold->Js.Dict.set(
+          lastBlockScannedData.blockNumber->Int.toString,
+          lastBlockScannedData,
         )
-      } else {
-        Data(lastBlockScannedDataListReversed)
+        switch firstBlockParentNumberAndHash {
+        | None => ()
+        | Some(firstBlockParentNumberAndHash) =>
+          dataByBlockNumberCopyInThreshold->Js.Dict.set(
+            firstBlockParentNumberAndHash.blockNumber->Int.toString,
+            firstBlockParentNumberAndHash,
+          )
+        }
+
+        Ok({
+          confirmedBlockThreshold,
+          dataByBlockNumber: dataByBlockNumberCopyInThreshold,
+        })
       }
-    | list{} => Data(list{})
     }
   }
 
-  //Prunes the back of the unneeded data on the queue
-  let pruneStaleBlockData = (
-    ~currentHeight,
-    ~earliestMultiChainTimestampInThreshold=?,
-    {confirmedBlockThreshold, lastBlockScannedDataList}: t,
+  let getLatestValidScannedBlock = (
+    self: t,
+    ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
+    ~currentBlockHeight,
   ) => {
-    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 verifiedDataByBlockNumber = Js.Dict.empty()
+    blockNumbersAndHashes->Array.forEach(blockData => {
+      verifiedDataByBlockNumber->Js.Dict.set(blockData.blockNumber->Int.toString, blockData)
+    })
 
-  let doBlockHashesMatch = (lastBlockScannedData, ~latestBlockHashes: blockNumberToHashMap) => {
-    let {blockNumber, blockHash} = lastBlockScannedData
-    let matchingBlock = latestBlockHashes->Belt.Map.Int.get(blockNumber)
+    let dataByBlockNumber = self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
+    // Js engine automatically orders numeric object keys
+    let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
 
-    switch matchingBlock {
-    | None => Error(BlockNotIncludedInMap(blockNumber))
-    | Some(latestBlockHash) => Ok(blockHash == latestBlockHash)
-    }
-  }
+    let getPrevScannedBlock = idx =>
+      ascBlockNumberKeys
+      ->Belt.Array.get(idx - 1)
+      ->Option.flatMap(key => {
+        // We should already validate that the block number is verified at the point
+        verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(key)
+      })
 
-  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)
+    let rec loop = idx => {
+      switch ascBlockNumberKeys->Belt.Array.get(idx) {
+      | Some(blockNumberKey) =>
+        let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+        switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
+        | None =>
+          Js.Exn.raiseError(
+            `Unexpected case. Couldn't find verified hash for block number ${blockNumberKey}`,
+          )
+        | Some(verifiedBlockData) if verifiedBlockData.blockHash === scannedBlock.blockHash =>
+          loop(idx + 1)
+        | Some(_) => getPrevScannedBlock(idx)
         }
-      })
+      | None => getPrevScannedBlock(idx)
+      }
     }
+    loop(0)
   }
 
   /**
-  Return a BlockNumbersAndHashes.t rolled back to where hashes
-  match the provided blockNumberAndHashes
+  Return a BlockNumbersAndHashes.t rolled back to where blockData is less
+  than the provided blockNumber
   */
-  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 = (
+  let rollbackToValidBlockNumber = (
+    {dataByBlockNumber, confirmedBlockThreshold}: t,
     ~blockNumber: int,
-    latestBlockScannedData: list<blockData>,
   ) => {
-    switch latestBlockScannedData {
-    | list{} => list{}
-    | list{head, ...tail} =>
-      if head.blockNumber < blockNumber {
-        latestBlockScannedData
-      } else {
-        tail->rollBackToBlockNumberLtInternal(~blockNumber)
+    // Js engine automatically orders numeric object keys
+    let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
+
+    let newDataByBlockNumber = Js.Dict.empty()
+
+    let rec loop = idx => {
+      switch ascBlockNumberKeys->Belt.Array.get(idx) {
+      | Some(blockNumberKey) => {
+          let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+          let shouldKeep = scannedBlock.blockNumber <= blockNumber
+          if shouldKeep {
+            newDataByBlockNumber->Js.Dict.set(blockNumberKey, scannedBlock)
+            loop(idx + 1)
+          } else {
+            ()
+          }
+        }
+      | None => ()
       }
     }
-  }
-
-  /**
-  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
+    loop(0)
 
-  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
+    {
+      confirmedBlockThreshold,
+      dataByBlockNumber: newDataByBlockNumber,
     }
   }
 
   let getThresholdBlockNumbers = (self: t, ~currentBlockHeight) => {
-    let blockNumbers = []
-    let thresholdBlocknumber = currentBlockHeight - self.confirmedBlockThreshold
-    self.lastBlockScannedDataList->Belt.List.forEach(v => {
-      if v.blockNumber >= thresholdBlocknumber {
-        blockNumbers->Belt.Array.push(v.blockNumber)
-      }
-    })
-    blockNumbers
-  }
+    let dataByBlockNumberCopyInThreshold =
+      self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
 
-  /**
-  Checks whether reorg has occured by comparing the parent hash with the last saved block hash.
-  */
-  let rec hasReorgOccurredInternal = (lastBlockScannedDataList, ~reorgGuard: reorgGuard) => {
-    switch lastBlockScannedDataList {
-    | list{head, ...tail} =>
-      switch reorgGuard {
-      | {lastBlockScannedData} if lastBlockScannedData.blockNumber == head.blockNumber =>
-        lastBlockScannedData.blockHash != head.blockHash
-      //If parentHash is None, either it's the genesis block (no reorg)
-      //Or its already confirmed so no Reorg
-      | {firstBlockParentNumberAndHash: None} => false
-      | {
-          firstBlockParentNumberAndHash: Some({
-            blockHash: parentHash,
-            blockNumber: parentBlockNumber,
-          }),
-        } =>
-        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(~reorgGuard)
-        }
-      }
-    //If recentLastBlockData is None, we have not yet saved blockData to compare against
-    | _ => false
-    }
+    dataByBlockNumberCopyInThreshold->Js.Dict.values->Js.Array2.map(v => v.blockNumber)
   }
-
-  let hasReorgOccurred = (lastBlockScannedHashes: t, ~reorgGuard: reorgGuard) =>
-    lastBlockScannedHashes.lastBlockScannedDataList->hasReorgOccurredInternal(~reorgGuard)
 }

package/src/db/EntityHistory.res

@@ -231,10 +231,12 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
   let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
 
   let originTableName = table.tableName
+  let originSchemaName = table.schemaName
   let historyTableName = originTableName ++ "_history"
   //ignore composite indices
   let table = mkTable(
     historyTableName,
+    ~schemaName=originSchemaName,
     ~fields=Belt.Array.concatMany([
       currentHistoryFields,
       previousHistoryFields,
@@ -245,8 +247,8 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let insertFnName = `"insert_${table.tableName}"`
   let historyRowArg = "history_row"
-  let historyTablePath = `"public"."${historyTableName}"`
-  let originTablePath = `"public"."${originTableName}"`
+  let historyTablePath = `"${originSchemaName}"."${historyTableName}"`
+  let originTablePath = `"${originSchemaName}"."${originTableName}"`
 
   let previousHistoryFieldsAreNullStr =
     previousChangeFieldNames

package/src/db/Table.res

@@ -86,16 +86,14 @@ let getFieldType = (field: field) => {
 
 type table = {
   tableName: string,
+  schemaName: string,
   fields: array<fieldOrDerived>,
   compositeIndices: array<array<string>>,
 }
 
-let mkTable: 'b. (
-  ~compositeIndices: array<array<string>>=?,
-  ~fields: array<fieldOrDerived>,
-  string,
-) => 'c = (~compositeIndices=[], ~fields, tableName) => {
+let mkTable = (tableName, ~schemaName, ~compositeIndices=[], ~fields) => {
   tableName,
+  schemaName,
   fields,
   compositeIndices,
 }
@@ -213,10 +211,7 @@ let toSqlParams = (table: table, ~schema) => {
             }
           | Bool =>
             // Workaround for https://github.com/porsager/postgres/issues/471
-            S.union([
-              S.literal("t")->S.to(_ => true),
-              S.literal("f")->S.to(_ => false),
-            ])->S.toUnknown
+            S.union([S.literal(1)->S.to(_ => true), S.literal(0)->S.to(_ => false)])->S.toUnknown
           | _ => schema
           }
 
@@ -242,6 +237,7 @@ let toSqlParams = (table: table, ~schema) => {
           | Field(f) =>
             switch f.fieldType {
             | Custom(fieldType) => `${(Text :> string)}[]::${(fieldType :> string)}`
+            | Boolean => `${(Integer :> string)}[]::${(f.fieldType :> string)}`
             | fieldType => (fieldType :> string)
             }
           | DerivedFrom(_) => (Text :> string)
@@ -308,7 +304,7 @@ module PostgresInterop = {
       table->getNonDefaultFieldNames->Array.map(fieldName => `"${fieldName}"`)
     `(sql, rows) => {
       return sql\`
-        INSERT INTO "public"."${table.tableName}"
+        INSERT INTO "${table.schemaName}"."${table.tableName}"
         \${sql(rows, ${fieldNamesInQuotes->Js.Array2.joinWith(", ")})}
         ON CONFLICT(${table->getPrimaryKeyFieldNames->Js.Array2.joinWith(", ")}) DO UPDATE
         SET