@across-protocol/sdk 4.1.42 → 4.1.44

package/src/addressAggregator/adapters/file.ts

@@ -1,37 +1,36 @@
 import { readFile } from "node:fs/promises";
 import { array, defaulted, string } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { Logger, logError } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
 const fileConfig = defaulted(array(string()), []);
 
-export class AddressList implements AddressListAdapter {
-  readonly name: string;
-
-  constructor(readonly path = "./addresses.json") {
-    this.name = `fs:${path}`;
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    const { path = "addresses.json" } = opts ?? {};
+    super(opts?.name ?? `fs:${path}`, path, opts);
   }
 
-  async update(logger?: Logger): Promise<string[]> {
+  async update(): Promise<string[]> {
     let data: string;
     try {
       data = await readFile(this.path, { encoding: "utf8" });
     } catch (err) {
-      return logError(this.name, err, logger);
+      return this.error(err);
     }
 
     if (!data) {
-      return logError(this.name, `No addresses found in "${this.path}"`, logger);
+      return this.error("No addresses found");
     }
 
     let addresses: unknown;
     try {
       addresses = JSON.parse(data);
       if (!fileConfig.is(addresses)) {
-        return logError(this.name, "Address format validation failure.", logger);
+        return this.error("Address format validation failure.");
       }
     } catch (err) {
-      return logError(this.name, err, logger);
+      return this.error(err);
     }
 
     return Promise.resolve(addresses);

package/src/addressAggregator/adapters/risklabs.ts

@@ -1,25 +1,26 @@
 import { array, string } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { logError, Logger, fetch } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
 const RESPONSE_TYPE = array(string());
 const DEFAULT_NAME = "Risk Labs";
 const DEFAULT_URL = "https://blacklist.risklabs.foundation/api/blacklist";
 
-export class AddressList implements AddressListAdapter {
-  readonly timeout = 2000; // ms
-  readonly retries = 1;
-
-  constructor(
-    readonly name = DEFAULT_NAME,
-    readonly url = DEFAULT_URL
-  ) {}
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    super(opts?.name ?? DEFAULT_NAME, opts?.path ?? DEFAULT_URL, opts);
+  }
 
-  async update(logger?: Logger): Promise<string[]> {
-    const response = await fetch(this.name, this.url, this.timeout, this.retries);
+  async update(): Promise<string[]> {
+    let response: unknown;
+    try {
+      response = await this.fetch(this.name, this.path, this.timeout, this.retries);
+    } catch (err) {
+      return this.error(err);
+    }
 
     if (!RESPONSE_TYPE.is(response)) {
-      return logError(this.name, "Failed to validate response", logger);
+      return this.error("Failed to validate response");
     }
 
     return response;

package/src/addressAggregator/index.ts

@@ -25,7 +25,7 @@ export class AddressAggregator {
 
     const allAddresses = await mapAsync(this.adapters, async (adapter) => {
       const invalidAddresses: string[] = [];
-      const addresses = (await adapter.update(this.logger))
+      const addresses = (await adapter.update())
         .map((address) => {
           try {
             return ethersUtils.getAddress(address.toLowerCase());
@@ -66,7 +66,7 @@ export class AddressAggregator {
 }
 
 async function run(): Promise<number> {
-  const addressList = new AddressAggregator([new adapters.risklabs.AddressList()]);
+  const addressList = new AddressAggregator([new adapters.risklabs.AddressList({ throwOnError: true })]);
 
   const addresses = await addressList.update();
   console.log(`Retrieved ${addresses.size} addresses: ${JSON.stringify(Array.from(addresses), null, 2)}`);

package/src/addressAggregator/types.ts

@@ -1,8 +1,17 @@
 import { Logger } from "../utils";
 
+export type AdapterOptions = {
+  name?: string;
+  path?: string;
+  retries?: number;
+  timeout?: number;
+  throwOnError?: boolean;
+  logger?: Logger;
+};
+
 export interface AddressListAdapter {
   readonly name: string;
-  update(logger?: Logger): Promise<string[]>;
+  update(): Promise<string[]>;
 }
 
 export const INVALID_ADDRESS = "";

package/src/arch/evm/SpokeUtils.ts

@@ -0,0 +1,324 @@
+import assert from "assert";
+import { BytesLike, Contract, PopulatedTransaction, providers } from "ethers";
+import { CHAIN_IDs } from "../../constants";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import {
+  bnUint32Max,
+  BigNumber,
+  toBN,
+  bnZero,
+  chunk,
+  getMessageHash,
+  getRelayDataHash,
+  isDefined,
+  isUnsafeDepositId,
+  isZeroAddress,
+  getDepositRelayData,
+  getNetworkName,
+  paginatedEventQuery,
+  spreadEventWithBlockNumber,
+  toBytes32,
+} from "../../utils";
+
+type BlockTag = providers.BlockTag;
+
+/**
+ * @param spokePool SpokePool Contract instance.
+ * @param deposit V3Deopsit instance.
+ * @param repaymentChainId Optional repaymentChainId (defaults to destinationChainId).
+ * @returns An Ethers UnsignedTransaction instance.
+ */
+export function populateV3Relay(
+  spokePool: Contract,
+  deposit: Omit<Deposit, "messageHash">,
+  relayer: string,
+  repaymentChainId = deposit.destinationChainId
+): Promise<PopulatedTransaction> {
+  const relayData = getDepositRelayData(deposit);
+
+  if (isDefined(deposit.speedUpSignature)) {
+    assert(isDefined(deposit.updatedRecipient) && !isZeroAddress(deposit.updatedRecipient));
+    assert(isDefined(deposit.updatedOutputAmount));
+    assert(isDefined(deposit.updatedMessage));
+    return spokePool.populateTransaction.fillRelayWithUpdatedDeposit(
+      relayData,
+      repaymentChainId,
+      toBytes32(relayer),
+      deposit.updatedOutputAmount,
+      toBytes32(deposit.updatedRecipient),
+      deposit.updatedMessage,
+      deposit.speedUpSignature,
+      { from: relayer }
+    );
+  }
+
+  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, toBytes32(relayer), { from: relayer });
+}
+
+/**
+ * Retrieves the time from the SpokePool contract at a particular block.
+ * @returns The time at the specified block tag.
+ */
+export async function getTimeAt(spokePool: Contract, blockNumber: number): Promise<number> {
+  const currentTime = await spokePool.getCurrentTime({ blockTag: blockNumber });
+  assert(BigNumber.isBigNumber(currentTime) && currentTime.lt(bnUint32Max));
+  return currentTime.toNumber();
+}
+
+/**
+ * Retrieves the chain time at a particular block.
+ * @note This should be the same as getTimeAt() but can differ in test. These two functions should be consolidated.
+ * @returns The chain time at the specified block tag.
+ */
+export async function getTimestampForBlock(provider: providers.Provider, blockNumber: number): Promise<number> {
+  const block = await provider.getBlock(blockNumber);
+  return block.timestamp;
+}
+
+/**
+ * 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 getMaxFillDeadlineInRange(
+  spokePool: Contract,
+  startBlock: number,
+  endBlock: number
+): Promise<number> {
+  const fillDeadlineBuffers = await Promise.all([
+    spokePool.fillDeadlineBuffer({ blockTag: startBlock }),
+    spokePool.fillDeadlineBuffer({ blockTag: endBlock }),
+  ]);
+  return Math.max(fillDeadlineBuffers[0], fillDeadlineBuffers[1]);
+}
+
+/**
+ * Finds the deposit id at a specific block number.
+ * @param blockTag The block number to search for the deposit ID at.
+ * @returns The deposit ID.
+ */
+export async function getDepositIdAtBlock(contract: Contract, blockTag: number): Promise<BigNumber> {
+  const _depositIdAtBlock = await contract.numberOfDeposits({ blockTag });
+  const depositIdAtBlock = toBN(_depositIdAtBlock);
+  // Sanity check to ensure that the deposit ID is greater than or equal to zero.
+  if (depositIdAtBlock.lt(bnZero)) {
+    throw new Error("Invalid deposit count");
+  }
+  return depositIdAtBlock;
+}
+
+export async function findDepositBlock(
+  spokePool: Contract,
+  depositId: BigNumber,
+  lowBlock: number,
+  highBlock?: number
+): Promise<number | undefined> {
+  // We can only perform this search when we have a safe deposit ID.
+  if (isUnsafeDepositId(depositId)) {
+    throw new Error(`Cannot binary search for depositId ${depositId}`);
+  }
+
+  highBlock ??= await spokePool.provider.getBlockNumber();
+  assert(highBlock > lowBlock, `Block numbers out of range (${lowBlock} >= ${highBlock})`);
+
+  // Make sure the deposit occurred within the block range supplied by the caller.
+  const [nDepositsLow, nDepositsHigh] = (
+    await Promise.all([
+      spokePool.numberOfDeposits({ blockTag: lowBlock }),
+      spokePool.numberOfDeposits({ blockTag: highBlock }),
+    ])
+  ).map((n) => toBN(n));
+
+  if (nDepositsLow.gt(depositId) || nDepositsHigh.lte(depositId)) {
+    return undefined; // Deposit did not occur within the specified block range.
+  }
+
+  // Find the lowest block number where numberOfDeposits is greater than the requested depositId.
+  do {
+    const midBlock = Math.floor((highBlock + lowBlock) / 2);
+    const nDeposits = toBN(await spokePool.numberOfDeposits({ blockTag: midBlock }));
+
+    if (nDeposits.gt(depositId)) {
+      highBlock = midBlock; // depositId occurred at or earlier than midBlock.
+    } else {
+      lowBlock = midBlock + 1; // depositId occurred later than midBlock.
+    }
+  } while (lowBlock < highBlock);
+
+  return lowBlock;
+}
+
+/**
+ * Find the amount filled for a deposit at a particular block.
+ * @param spokePool SpokePool contract instance.
+ * @param relayData Deposit information that is used to complete a fill.
+ * @param blockTag Block tag (numeric or "latest") to query at.
+ * @returns The amount filled for the specified deposit at the requested block (or latest).
+ */
+export async function relayFillStatus(
+  spokePool: Contract,
+  relayData: RelayData,
+  blockTag?: number | "latest",
+  destinationChainId?: number
+): Promise<FillStatus> {
+  destinationChainId ??= await spokePool.chainId();
+  assert(isDefined(destinationChainId));
+
+  const hash = getRelayDataHash(relayData, destinationChainId);
+  const _fillStatus = await spokePool.fillStatuses(hash, { blockTag });
+  const fillStatus = Number(_fillStatus);
+
+  if (![FillStatus.Unfilled, FillStatus.RequestedSlowFill, FillStatus.Filled].includes(fillStatus)) {
+    const { originChainId, depositId } = relayData;
+    throw new Error(
+      `relayFillStatus: Unexpected fillStatus for ${originChainId} deposit ${depositId.toString()} (${fillStatus})`
+    );
+  }
+
+  return fillStatus;
+}
+
+export async function fillStatusArray(
+  spokePool: Contract,
+  relayData: RelayData[],
+  blockTag: BlockTag = "latest"
+): Promise<(FillStatus | undefined)[]> {
+  const fillStatuses = "fillStatuses";
+  const destinationChainId = await spokePool.chainId();
+
+  const queries = relayData.map((relayData) => {
+    const hash = getRelayDataHash(relayData, destinationChainId);
+    return spokePool.interface.encodeFunctionData(fillStatuses, [hash]);
+  });
+
+  // Chunk the hashes into appropriate sizes to avoid death by rpc.
+  const chunkSize = 250;
+  const chunkedQueries = chunk(queries, chunkSize);
+
+  const multicalls = await Promise.all(
+    chunkedQueries.map((queries) => spokePool.callStatic.multicall(queries, { blockTag }))
+  );
+  const status = multicalls
+    .map((multicall: BytesLike[]) =>
+      multicall.map((result) => spokePool.interface.decodeFunctionResult(fillStatuses, result)[0])
+    )
+    .flat();
+
+  const bnUnfilled = toBN(FillStatus.Unfilled);
+  const bnFilled = toBN(FillStatus.Filled);
+
+  return status.map((status: unknown) => {
+    return BigNumber.isBigNumber(status) && status.gte(bnUnfilled) && status.lte(bnFilled)
+      ? status.toNumber()
+      : undefined;
+  });
+}
+
+/**
+ * Find the block at which a fill was completed.
+ * @todo After SpokePool upgrade, this function can be simplified to use the FillStatus enum.
+ * @param spokePool SpokePool contract instance.
+ * @param relayData Deposit information that is used to complete a fill.
+ * @param lowBlockNumber The lower bound of the search. Must be bounded by SpokePool deployment.
+ * @param highBlocknumber Optional upper bound for the search.
+ * @returns The block number at which the relay was completed, or undefined.
+ */
+export async function findFillBlock(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<number | undefined> {
+  const { provider } = spokePool;
+  highBlockNumber ??= await provider.getBlockNumber();
+  assert(highBlockNumber > lowBlockNumber, `Block numbers out of range (${lowBlockNumber} >= ${highBlockNumber})`);
+
+  // In production the chainId returned from the provider matches 1:1 with the actual chainId. Querying the provider
+  // object saves an RPC query because the chainId is cached by StaticJsonRpcProvider instances. In hre, the SpokePool
+  // may be configured with a different chainId than what is returned by the provider.
+  const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
+    ? (await provider.getNetwork()).chainId
+    : Number(await spokePool.chainId());
+  assert(
+    relayData.originChainId !== destinationChainId,
+    `Origin & destination chain IDs must not be equal (${destinationChainId})`
+  );
+
+  // Make sure the relay was completed within the block range supplied by the caller.
+  const [initialFillStatus, finalFillStatus] = (
+    await Promise.all([
+      relayFillStatus(spokePool, relayData, lowBlockNumber, destinationChainId),
+      relayFillStatus(spokePool, relayData, highBlockNumber, destinationChainId),
+    ])
+  ).map(Number);
+
+  if (finalFillStatus !== FillStatus.Filled) {
+    return undefined; // Wasn't filled within the specified block range.
+  }
+
+  // Was filled earlier than the specified lowBlock. This is an error by the caller.
+  if (initialFillStatus === FillStatus.Filled) {
+    const { depositId, originChainId } = relayData;
+    const [srcChain, dstChain] = [getNetworkName(originChainId), getNetworkName(destinationChainId)];
+    throw new Error(`${srcChain} deposit ${depositId.toString()} filled on ${dstChain} before block ${lowBlockNumber}`);
+  }
+
+  // Find the leftmost block where filledAmount equals the deposit amount.
+  do {
+    const midBlockNumber = Math.floor((highBlockNumber + lowBlockNumber) / 2);
+    const fillStatus = await relayFillStatus(spokePool, relayData, midBlockNumber, destinationChainId);
+
+    if (fillStatus === FillStatus.Filled) {
+      highBlockNumber = midBlockNumber;
+    } else {
+      lowBlockNumber = midBlockNumber + 1;
+    }
+  } while (lowBlockNumber < highBlockNumber);
+
+  return lowBlockNumber;
+}
+
+export async function findFillEvent(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<FillWithBlock | undefined> {
+  const blockNumber = await findFillBlock(spokePool, relayData, lowBlockNumber, highBlockNumber);
+  if (!blockNumber) return undefined;
+
+  // We can hardcode this to 0 to instruct paginatedEventQuery to make a single request for the same block number.
+  const maxBlockLookBack = 0;
+  const [fromBlock, toBlock] = [blockNumber, blockNumber];
+
+  const query = (
+    await Promise.all([
+      paginatedEventQuery(
+        spokePool,
+        spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+        { fromBlock, toBlock, maxBlockLookBack }
+      ),
+      paginatedEventQuery(
+        spokePool,
+        spokePool.filters.FilledV3Relay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+        { fromBlock, toBlock, maxBlockLookBack }
+      ),
+    ])
+  ).flat();
+  if (query.length === 0) throw new Error(`Failed to find fill event at block ${blockNumber}`);
+  const event = query[0];
+  // In production the chainId returned from the provider matches 1:1 with the actual chainId. Querying the provider
+  // object saves an RPC query because the chainId is cached by StaticJsonRpcProvider instances. In hre, the SpokePool
+  // may be configured with a different chainId than what is returned by the provider.
+  const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
+    ? (await spokePool.provider.getNetwork()).chainId
+    : Number(await spokePool.chainId());
+  const fill = {
+    ...spreadEventWithBlockNumber(event),
+    destinationChainId,
+    messageHash: getMessageHash(event.args.message),
+  } as FillWithBlock;
+  return fill;
+}

package/src/arch/evm/index.ts

@@ -1 +1 @@
-export const platform = "evm"; // Placeholder for actual exports.
+export * from "./SpokeUtils";

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -20,6 +20,7 @@ import {
   DepositWithBlock,
 } from "../../interfaces";
 import { SpokePoolClient } from "..";
+import { findFillEvent } from "../../arch/evm";
 import {
   BigNumber,
   bnZero,
@@ -37,7 +38,6 @@ import {
   mapAsync,
   bnUint32Max,
   isZeroValueDeposit,
-  findFillEvent,
   isZeroValueFillOrSlowFillRequest,
   chainIsEvm,
   isValidEvmAddress,
@@ -728,8 +728,7 @@ export class BundleDataClient {
         // hasn't queried. This is because this function will usually be called
         // in production with block ranges that were validated by
         // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
-        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestBlockSearched),
-        deposit.destinationChainId
+        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestBlockSearched)
       );
     };
 

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -1,5 +1,22 @@
 import { Contract, EventFilter } from "ethers";
-import { BigNumber, DepositSearchResult, getNetworkName, InvalidFill, MakeOptional, toBN } from "../../utils";
+import {
+  fillStatusArray,
+  findDepositBlock,
+  getMaxFillDeadlineInRange as getMaxFillDeadline,
+  getTimeAt as _getTimeAt,
+  relayFillStatus,
+  getTimestampForBlock as _getTimestampForBlock,
+} from "../../arch/evm";
+import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
+import {
+  BigNumber,
+  DepositSearchResult,
+  getNetworkName,
+  InvalidFill,
+  isZeroAddress,
+  MakeOptional,
+  toBN,
+} from "../../utils";
 import {
   EventSearchConfig,
   paginatedEventQuery,
@@ -10,15 +27,6 @@ import { isUpdateFailureReason } from "../BaseAbstractClient";
 import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
 import winston from "winston";
 import { HubPoolClient } from "../HubPoolClient";
-import {
-  findDepositBlock,
-  getMaxFillDeadlineInRange as getMaxFillDeadline,
-  getTimeAt as _getTimeAt,
-  relayFillStatus,
-  isZeroAddress,
-  getTimestampForBlock as _getTimestampForBlock,
-} from "../../utils/SpokeUtils";
-import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
 
 /**
  * An EVM-specific SpokePoolClient.
@@ -35,12 +43,15 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     super(logger, hubPoolClient, chainId, deploymentBlock, eventSearchConfig);
   }
 
-  public override relayFillStatus(
-    relayData: RelayData,
-    blockTag?: number | "latest",
-    destinationChainId?: number
-  ): Promise<FillStatus> {
-    return relayFillStatus(this.spokePool, relayData, blockTag, destinationChainId);
+  public override relayFillStatus(relayData: RelayData, blockTag?: number | "latest"): Promise<FillStatus> {
+    return relayFillStatus(this.spokePool, relayData, blockTag, this.chainId);
+  }
+
+  public override fillStatusArray(
+    relayData: RelayData[],
+    blockTag?: number | "latest"
+  ): Promise<(FillStatus | undefined)[]> {
+    return fillStatusArray(this.spokePool, relayData, blockTag);
   }
 
   public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -810,11 +810,19 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
   /**
    * Retrieves the fill status for a given relay data.
    * @param relayData The relay data to retrieve the fill status for.
+   * @param blockTag The block at which to query the fill status.
    * @returns The fill status for the given relay data.
    */
-  public abstract relayFillStatus(
-    relayData: RelayData,
-    blockTag?: number | "latest",
-    destinationChainId?: number
-  ): Promise<FillStatus>;
+  public abstract relayFillStatus(relayData: RelayData, blockTag?: number | "latest"): Promise<FillStatus>;
+
+  /**
+   * Retrieves the fill status for an array of given relay data.
+   * @param relayData The array relay data to retrieve the fill status for.
+   * @param blockTag The block at which to query the fill status.
+   * @returns The fill status for each of the given relay data.
+   */
+  public abstract fillStatusArray(
+    relayData: RelayData[],
+    blockTag?: number | "latest"
+  ): Promise<(FillStatus | undefined)[]>;
 }

package/src/constants.ts

@@ -66,6 +66,19 @@ export const BRIDGED_USDC_SYMBOLS = [
   TOKEN_SYMBOLS_MAP.USDzC.symbol,
 ];
 
+export const STABLE_COIN_SYMBOLS = [
+  ...BRIDGED_USDC_SYMBOLS,
+  TOKEN_SYMBOLS_MAP.USDB.symbol,
+  TOKEN_SYMBOLS_MAP.USDC.symbol,
+  TOKEN_SYMBOLS_MAP.USDT.symbol,
+  TOKEN_SYMBOLS_MAP.DAI.symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDC"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDT"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDS"].symbol,
+  TOKEN_SYMBOLS_MAP.GHO.symbol,
+  TOKEN_SYMBOLS_MAP.WGHO.symbol,
+];
+
 export const CUSTOM_GAS_TOKENS = {
   [CHAIN_IDs.POLYGON]: "MATIC",
   [CHAIN_IDs.POLYGON_AMOY]: "MATIC",

package/src/index.ts

@@ -1,3 +1,4 @@
+export * as arch from "./arch";
 export * as addressAggregator from "./addressAggregator";
 export * as lpFeeCalculator from "./lpFeeCalculator";
 export * as pool from "./pool";

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -6,10 +6,10 @@ import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs, DEFAULT_SIMULATED_RELAYER_ADDRESS } from "../../constants";
 import { Deposit } from "../../interfaces";
 import { SpokePool, SpokePool__factory } from "../../typechain";
+import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
   TransactionCostEstimate,
-  populateV3Relay,
   BigNumber,
   toBNWei,
   bnZero,

package/src/utils/DepositUtils.ts

@@ -2,10 +2,10 @@ import assert from "assert";
 import { SpokePoolClient } from "../clients";
 import { DEFAULT_CACHING_TTL, EMPTY_MESSAGE, UNDEFINED_MESSAGE_HASH, ZERO_BYTES } from "../constants";
 import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, RelayData, SlowFillRequest } from "../interfaces";
+import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getNetworkName } from "./NetworkUtils";
 import { bnZero } from "./BigNumberUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
-import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getCurrentTime } from "./TimeUtils";
 import { isDefined } from "./TypeGuards";
 import { isDepositFormedCorrectly } from "./ValidatorUtils";
@@ -37,6 +37,7 @@ export type DepositSearchResult =
  * @throws If the fill's origin chain ID does not match the spoke pool client's chain ID.
  * @throws If the spoke pool client has not been updated.
  */
+// @todo relocate
 export async function queryHistoricalDepositForFill(
   spokePoolClient: SpokePoolClient,
   fill: Fill | SlowFillRequest,