envio 2.9.1 → 2.11.0

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/TopicFilter.res

@@ -0,0 +1,27 @@
+let toTwosComplement = (num: bigint, ~bytesLen: int) => {
+  let maxValue = 1n->BigInt.Bitwise.shift_left(BigInt.fromInt(bytesLen * 8))
+  let mask = maxValue->BigInt.sub(1n)
+  num->BigInt.add(maxValue)->BigInt.Bitwise.logand(mask)
+}
+
+let fromSignedBigInt = val => {
+  let bytesLen = 32
+  let val = val >= 0n ? val : val->toTwosComplement(~bytesLen)
+  val->Viem.bigintToHex(~options={size: bytesLen})
+}
+
+type hex = EvmTypes.Hex.t
+//bytes currently does not work with genType and we also currently generate bytes as a string type
+type bytesHex = string
+let keccak256 = Viem.keccak256
+let bytesToHex = Viem.bytesToHex
+let concat = Viem.concat
+let castToHexUnsafe: 'a => hex = val => val->Utils.magic
+let fromBigInt: bigint => hex = val => val->Viem.bigintToHex(~options={size: 32})
+let fromDynamicString: string => hex = val => val->(Utils.magic: string => hex)->keccak256
+let fromString: string => hex = val => val->Viem.stringToHex(~options={size: 32})
+let fromAddress: Address.t => hex = addr => addr->(Utils.magic: Address.t => hex)->Viem.pad
+let fromDynamicBytes: bytesHex => hex = bytes => bytes->(Utils.magic: bytesHex => hex)->keccak256
+let fromBytes: bytesHex => hex = bytes =>
+  bytes->(Utils.magic: bytesHex => bytes)->Viem.bytesToHex(~options={size: 32})
+let fromBool: bool => hex = b => b->Viem.boolToHex(~options={size: 32})

package/src/Utils.res

@@ -1,5 +1,12 @@
 external magic: 'a => 'b = "%identity"
 
+let delay = milliseconds =>
+  Js.Promise2.make((~resolve, ~reject as _) => {
+    let _interval = Js.Global.setTimeout(_ => {
+      resolve()
+    }, milliseconds)
+  })
+
 module Option = {
   let mapNone = (opt: option<'a>, val: 'b): option<'b> => {
     switch opt {
@@ -224,6 +231,13 @@ external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 module Schema = {
   let enum = items => S.union(items->Belt.Array.mapU(S.literal))
 
+  // A hot fix after we use the version where it's supported
+  // https://github.com/DZakh/rescript-schema/blob/v8.4.0/docs/rescript-usage.md#removetypevalidation
+  let removeTypeValidationInPlace = schema => {
+    // The variables input is guaranteed to be an object, so we reset the rescript-schema type filter here
+    (schema->Obj.magic)["f"] = ()
+  }
+
   let getNonOptionalFieldNames = schema => {
     let acc = []
     switch schema->S.classify {
@@ -362,3 +376,15 @@ module WeakMap = {
   @send external has: (t<'k, 'v>, 'k) => bool = "has"
   @send external set: (t<'k, 'v>, 'k, 'v) => t<'k, 'v> = "set"
 }
+
+module Map = {
+  type t<'k, 'v> = Js.Map.t<'k, 'v>
+
+  @new external make: unit => t<'k, 'v> = "Map"
+
+  @send external get: (t<'k, 'v>, 'k) => option<'v> = "get"
+  @send external unsafeGet: (t<'k, 'v>, 'k) => 'v = "get"
+  @send external has: (t<'k, 'v>, 'k) => bool = "has"
+  @send external set: (t<'k, 'v>, 'k, 'v) => t<'k, 'v> = "set"
+  @send external delete: (t<'k, 'v>, 'k) => bool = "delete"
+}

package/src/bindings/BigInt.res

@@ -48,10 +48,22 @@ let schema =
   S.string
   ->S.setName("BigInt")
   ->S.transform(s => {
-    parser: (. string) =>
+    parser: string =>
       switch string->fromString {
       | Some(bigInt) => bigInt
-      | None => s.fail(. "The string is not valid BigInt")
+      | None => s.fail("The string is not valid BigInt")
       },
-    serializer: (. bigint) => bigint->toString,
+    serializer: bigint => bigint->toString,
   })
+
+let nativeSchema: S.t<bigint> = S.custom("BigInt", s => {
+  {
+    parser: unknown => {
+      if Js.typeof(unknown) !== "bigint" {
+        s.fail("Expected bigint")
+      } else {
+        unknown->Obj.magic
+      }
+    },
+  }
+})

package/src/bindings/Ethers.gen.ts

@@ -0,0 +1,14 @@
+/* TypeScript file generated from Ethers.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+const EthersJS = require('./Ethers.bs.js');
+
+import type {t as Address_t} from '../../src/Address.gen';
+
+export const Addresses_mockAddresses: Address_t[] = EthersJS.Addresses.mockAddresses as any;
+
+export const Addresses_defaultAddress: Address_t = EthersJS.Addresses.defaultAddress as any;
+
+export const Addresses: { mockAddresses: Address_t[]; defaultAddress: Address_t } = EthersJS.Addresses as any;