@across-protocol/sdk 4.1.29 → 4.1.31

package/src/utils/SpokeUtils.ts

@@ -1,10 +1,9 @@
 import assert from "assert";
 import { BytesLike, Contract, PopulatedTransaction, providers, utils as ethersUtils } from "ethers";
-import { CHAIN_IDs, MAX_SAFE_DEPOSIT_ID, UNDEFINED_MESSAGE_HASH, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
+import { CHAIN_IDs, MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
 import { Deposit, FillStatus, FillWithBlock, RelayData } from "../interfaces";
-import { SpokePoolClient } from "../clients";
 import { chunk } from "./ArrayUtils";
-import { BigNumber, toBN, bnOne, bnZero } from "./BigNumberUtils";
+import { BigNumber, toBN, bnZero } from "./BigNumberUtils";
 import { keccak256 } from "./common";
 import { isMessageEmpty } from "./DepositUtils";
 import { isDefined } from "./TypeGuards";
@@ -60,219 +59,31 @@ export function populateV3Relay(
 }
 
 /**
- * Concatenate all fields from a Deposit, Fill or SlowFillRequest into a single string.
- * This can be used to identify a bridge event in a mapping. This is used instead of the actual keccak256 hash
- * (getRelayDataHash()) for two reasons: performance and the fact that only Deposit includes the `message` field, which
- * is required to compute a complete RelayData hash.
- * note: This function should _not_ be used to query the SpokePool.fillStatuses mapping.
+ * Retrieves the chain time at a particular block.
+ * @returns The time at the specified block tag.
  */
-export function getRelayEventKey(
-  data: Omit<RelayData, "message"> & { messageHash: string; destinationChainId: number }
-): string {
-  return [
-    data.depositor,
-    data.recipient,
-    data.exclusiveRelayer,
-    data.inputToken,
-    data.outputToken,
-    data.inputAmount,
-    data.outputAmount,
-    data.originChainId,
-    data.destinationChainId,
-    data.depositId,
-    data.fillDeadline,
-    data.exclusivityDeadline,
-    data.messageHash,
-  ]
-    .map(String)
-    .join("-");
-}
-
-const RELAYDATA_KEYS = [
-  "depositId",
-  "originChainId",
-  "destinationChainId",
-  "depositor",
-  "recipient",
-  "inputToken",
-  "inputAmount",
-  "outputToken",
-  "outputAmount",
-  "fillDeadline",
-  "exclusivityDeadline",
-  "exclusiveRelayer",
-  "messageHash",
-] as const;
-
-// Ensure that each deposit element is included with the same value in the fill. This includes all elements defined
-// by the depositor as well as destinationToken, which are pulled from other clients.
-export function validateFillForDeposit(
-  relayData: Omit<RelayData, "message"> & { messageHash: string; destinationChainId: number },
-  deposit?: Omit<Deposit, "quoteTimestamp" | "fromLiteChain" | "toLiteChain">
-): { valid: true } | { valid: false; reason: string } {
-  if (deposit === undefined) {
-    return { valid: false, reason: "Deposit is undefined" };
-  }
-
-  // Note: this short circuits when a key is found where the comparison doesn't match.
-  // TODO: if we turn on "strict" in the tsconfig, the elements of FILL_DEPOSIT_COMPARISON_KEYS will be automatically
-  // validated against the fields in Fill and Deposit, generating an error if there is a discrepency.
-  let invalidKey = RELAYDATA_KEYS.find((key) => relayData[key].toString() !== deposit[key].toString());
-
-  // There should be no paths for `messageHash` to be unset, but mask it off anyway.
-  if (!isDefined(invalidKey) && [relayData.messageHash, deposit.messageHash].includes(UNDEFINED_MESSAGE_HASH)) {
-    invalidKey = "messageHash";
-  }
-
-  return isDefined(invalidKey)
-    ? { valid: false, reason: `${invalidKey} mismatch (${relayData[invalidKey]} != ${deposit[invalidKey]})` }
-    : { valid: true };
+export async function getTimeAt(provider: providers.Provider, blockNumber: number): Promise<number> {
+  const block = await provider.getBlock(blockNumber);
+  return block.timestamp;
 }
 
 /**
- * Find the block range that contains the deposit ID. This is a binary search that searches for the block range
- * that contains the deposit ID.
- * @param targetDepositId The target deposit ID to search for.
- * @param initLow The initial lower bound of the block range to search.
- * @param initHigh The initial upper bound of the block range to search.
- * @param maxSearches The maximum number of searches to perform. This is used to prevent infinite loops.
- * @returns The block range that contains the deposit ID.
- * @note  // We want to find the block range that satisfies these conditions:
- *        // - the low block has deposit count <= targetDepositId
- *        // - the high block has a deposit count > targetDepositId.
- *        // This way the caller can search for a V3FundsDeposited event between [low, high] that will always
- *        // contain the event emitted when deposit ID was incremented to targetDepositId + 1. This is the same transaction
- *        // where the deposit with deposit ID = targetDepositId was created.
+ * Return maximum of fill deadline buffer at start and end of block range.
+ * @param spokePool SpokePool contract instance
+ * @param startBlock start block
+ * @param endBlock end block
+ * @returns maximum of fill deadline buffer at start and end block
  */
-export async function getBlockRangeForDepositId(
-  targetDepositId: BigNumber,
-  initLow: number,
-  initHigh: number,
-  maxSearches: number,
-  spokePool: SpokePoolClient
-): Promise<{
-  low: number;
-  high: number;
-}> {
-  // We can only perform this search when we have a safe deposit ID.
-  if (isUnsafeDepositId(targetDepositId))
-    throw new Error(
-      `Target deposit ID ${targetDepositId} is deterministic and therefore unresolvable via a binary search.`
-    );
-
-  // Resolve the deployment block number.
-  const deploymentBlock = spokePool.deploymentBlock;
-
-  // Set the initial high block to the most recent block number or the initial high block, whichever is smaller.
-  initHigh = Math.min(initHigh, spokePool.latestBlockSearched);
-
-  // We will now set a list of sanity checks to ensure that the binary search will not fail
-  // due to invalid input parameters.
-  // If any of these sanity checks fail, then we will throw an error.
-  (
-    [
-      // Sanity check to ensure that the spoke pool client is updated
-      [spokePool.isUpdated, "Spoke pool client is not updated"],
-      // Sanity check to ensure that initHigh is greater than or equal to initLow.
-      [initLow <= initHigh, "Binary search failed because low > high"],
-      // Sanity check to ensure that init Low is greater than or equal to zero.
-      [initLow >= deploymentBlock, "Binary search failed because low must be >= deploymentBlock"],
-      // Sanity check to ensure that maxSearches is greater than zero.
-      [maxSearches > 0, "maxSearches must be > 0"],
-      // Sanity check to ensure that deploymentBlock is greater than or equal to zero.
-      [deploymentBlock >= 0, "deploymentBlock must be >= 0"],
-    ] as [boolean, string][]
-  ).forEach(([condition, errorMessage]) => {
-    // If the condition is false, then we will throw an error.
-    if (!condition) {
-      throw new Error(errorMessage);
-    }
-  });
-
-  // Define a mapping of block numbers to number of deposits at that block. This saves repeated lookups.
-  const queriedIds: Record<number, BigNumber> = {};
-
-  // Define a llambda function to get the deposit ID at a block number. This function will first check the
-  // queriedIds cache to see if the deposit ID at the block number has already been queried. If not, it will
-  // make an eth_call request to get the deposit ID at the block number. It will then cache the deposit ID
-  // in the queriedIds cache.
-  const _getDepositIdAtBlock = async (blockNumber: number): Promise<BigNumber> => {
-    queriedIds[blockNumber] ??= await spokePool._getDepositIdAtBlock(blockNumber);
-    return queriedIds[blockNumber];
-  };
-
-  // Get the the deposit ID at the low block, and the deposit ID at the high block in parallel.
-  const [highestDepositIdInRange, lowestDepositIdInRange] = await Promise.all([
-    _getDepositIdAtBlock(initHigh),
-    _getDepositIdAtBlock(Math.max(deploymentBlock, initLow - 1)),
+export async function getMaxFillDeadlineInRange(
+  spokePool: Contract,
+  startBlock: number,
+  endBlock: number
+): Promise<number> {
+  const fillDeadlineBuffers = await Promise.all([
+    spokePool.fillDeadlineBuffer({ blockTag: startBlock }),
+    spokePool.fillDeadlineBuffer({ blockTag: endBlock }),
   ]);
-
-  // If the deposit ID at the initial high block is less than the target deposit ID, then we know that
-  // the target deposit ID must be greater than the initial high block, so we can throw an error.
-  if (highestDepositIdInRange.lte(targetDepositId)) {
-    // initLow   = 5: Deposits Num: 10
-    //                                     // targetId = 11  <- fail (triggers this error)          // 10 <= 11
-    //                                     // targetId = 10  <- fail (triggers this error)          // 10 <= 10
-    //                                     // targetId = 09  <- pass (does not trigger this error)  // 10 <= 09
-    throw new Error(
-      `Target depositId is greater than the initial high block (${targetDepositId} > ${highestDepositIdInRange})`
-    );
-  }
-
-  // If the deposit ID at the initial low block is greater than the target deposit ID, then we know that
-  // the target deposit ID must be less than the initial low block, so we can throw an error.
-  if (lowestDepositIdInRange.gt(targetDepositId)) {
-    // initLow   = 5: Deposits Num: 10
-    // initLow-1 = 4: Deposits Num:  2
-    //                                     // targetId = 1 <- fail (triggers this error)
-    //                                     // targetId = 2 <- pass (does not trigger this error)
-    //                                     // targetId = 3 <- pass (does not trigger this error)
-    throw new Error(
-      `Target depositId is less than the initial low block (${targetDepositId.toString()} > ${lowestDepositIdInRange})`
-    );
-  }
-
-  // Define the low and high block numbers for the binary search.
-  let low = initLow;
-  let high = initHigh;
-  // Define the number of searches performed so far.
-  let searches = 0;
-
-  do {
-    // Resolve the mid point of the block range.
-    const mid = Math.floor((low + high) / 2);
-
-    // Get the deposit ID at the mid point.
-    const midDepositId = await _getDepositIdAtBlock(mid);
-
-    // Let's define the latest ID of the current midpoint block.
-    const accountedIdByMidBlock = midDepositId.sub(bnOne);
-
-    // If our target deposit ID is less than the smallest range of our
-    // midpoint deposit ID range, then we know that the target deposit ID
-    // must be in the lower half of the block range.
-    if (targetDepositId.lte(accountedIdByMidBlock)) {
-      high = mid;
-    }
-    // If our target deposit ID is greater than the largest range of our
-    // midpoint deposit ID range, then we know that the target deposit ID
-    // must be in the upper half of the block range.
-    else {
-      low = mid + 1;
-    }
-
-    // We want to iterate until we've either found the block range or we've
-    // exceeded the maximum number of searches.
-  } while (++searches <= maxSearches && low < high);
-
-  // Sanity check to ensure that our low was not greater than our high.
-  if (low > high) {
-    throw new Error(`Binary search failed (${low} > ${high}). SHOULD NEVER HAPPEN (but here we are)`);
-  }
-
-  // We've either found the block range or we've exceeded the maximum number of searches.
-  // In either case, the block range is [low, high] so we can return it.
-  return { low, high };
+  return Math.max(fillDeadlineBuffers[0], fillDeadlineBuffers[1]);
 }
 
 /**