@across-protocol/sdk 4.1.45-beta.1 → 4.1.46-beta.0

package/src/clients/BundleDataClient/utils/FillUtils.ts

@@ -1,120 +1,124 @@
 import _ from "lodash";
-import assert from "assert";
 import { providers } from "ethers";
-import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
-import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
+import { Deposit, DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
+import { getBlockRangeForChain, isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 
-/**
- * @notice FillRepaymentInformation is a fill with additional properties required to determine where it can
- * be repaid.
- */
-type FillRepaymentInformation = Fill & { fromLiteChain: boolean };
-
-/**
- * @notice Return repayment chain and repayment token for a fill, but does not verify if the returned
- * repayment information is valid for the desired repayment address.
- * @dev The passed in fill should be verified first via verifyFillRepayment().
- * @param fill The fill to get the repayment information for.
- * @return The chain to send the refund to and the token to use for the refund.
- */
 export function getRefundInformationFromFill(
-  relayData: FillRepaymentInformation,
+  fill: Fill,
   hubPoolClient: HubPoolClient,
-  bundleEndBlockForMainnet: number
+  blockRangesForChains: number[][],
+  chainIdListForBundleEvaluationBlockNumbers: number[],
+  fromLiteChain: boolean
 ): {
   chainToSendRefundTo: number;
   repaymentToken: string;
 } {
-  const chainToSendRefundTo = _getRepaymentChainId(relayData, hubPoolClient, bundleEndBlockForMainnet);
-  if (chainToSendRefundTo === relayData.originChainId) {
-    return {
-      chainToSendRefundTo,
-      repaymentToken: relayData.inputToken,
-    };
+  // Handle slow relay where repaymentChainId = 0. Slow relays always pay recipient on destination chain.
+  // So, save the slow fill under the destination chain, and save the fast fill under its repayment chain.
+  let chainToSendRefundTo = isSlowFill(fill) ? fill.destinationChainId : fill.repaymentChainId;
+  // If the fill is for a deposit originating from the lite chain, the repayment chain is the origin chain
+  // regardless of whether it is a slow or fast fill (we ignore slow fills but this is for posterity).
+  // @note fill.repaymentChainId should already be set to originChainId but reset it to be safe.
+  if (fromLiteChain) {
+    chainToSendRefundTo = fill.originChainId;
   }
 
-  // Now figure out the equivalent L2 token for the repayment token. If the inputToken doesn't have a
-  // PoolRebalanceRoute, then the repayment chain would have been the originChainId after the getRepaymentChainId()
-  // call and we would have returned already, so the following call should always succeed.
+  // Save fill data and associate with repayment chain and L2 token refund should be denominated in.
+  const endBlockForMainnet = getBlockRangeForChain(
+    blockRangesForChains,
+    hubPoolClient.chainId,
+    chainIdListForBundleEvaluationBlockNumbers
+  )[1];
+
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-    relayData.inputToken,
-    relayData.originChainId,
-    bundleEndBlockForMainnet
+    fill.inputToken,
+    fill.originChainId,
+    endBlockForMainnet
   );
 
   const repaymentToken = hubPoolClient.getL2TokenForL1TokenAtBlock(
     l1TokenCounterpart,
     chainToSendRefundTo,
-    bundleEndBlockForMainnet
+    endBlockForMainnet
   );
   return {
     chainToSendRefundTo,
     repaymentToken,
   };
 }
-/**
- * @notice Verifies that the fill can be repaid. If the repayment address is not
- * valid for the requested repayment chain, then this function will attempt to change the fill's repayment chain
- * to the destination chain and its repayment address to the  msg.sender and if this is possible,
- * return the fill. Otherwise, return undefined.
- * @param _fill Fill with a requested repayment chain and address
- * @return Fill with the applied repayment chain (depends on the validity of the requested repayment address)
- * and applied repayment address, or undefined if the applied repayment address is not valid for the
- * applied repayment chain.
- */
+
+export function getRepaymentChainId(fill: Fill, matchedDeposit: Deposit): number {
+  // Lite chain deposits force repayment on origin chain.
+  return matchedDeposit.fromLiteChain ? matchedDeposit.originChainId : fill.repaymentChainId;
+}
+
+export function forceDestinationRepayment(
+  repaymentChainId: number,
+  matchedDeposit: Deposit & { quoteBlockNumber: number },
+  hubPoolClient: HubPoolClient
+): boolean {
+  if (!matchedDeposit.fromLiteChain) {
+    try {
+      const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
+        matchedDeposit.inputToken,
+        matchedDeposit.originChainId,
+        matchedDeposit.quoteBlockNumber
+      );
+      hubPoolClient.getL2TokenForL1TokenAtBlock(l1TokenCounterpart, repaymentChainId, matchedDeposit.quoteBlockNumber);
+      // Repayment token could be found, this is a valid repayment chain.
+      return false;
+    } catch {
+      // Repayment token doesn't exist on repayment chain via PoolRebalanceRoutes, impossible to repay filler there.
+      return true;
+    }
+  } else {
+    return false;
+  }
+}
+
+// Verify that a fill sent to an EVM chain has a 20 byte address. If the fill does not, then attempt
+// to repay the `msg.sender` of the relay transaction. Otherwise, return undefined.
 export async function verifyFillRepayment(
   _fill: FillWithBlock,
   destinationChainProvider: providers.Provider,
   matchedDeposit: DepositWithBlock,
-  hubPoolClient: HubPoolClient,
-  bundleEndBlockForMainnet: number
+  hubPoolClient: HubPoolClient
 ): Promise<FillWithBlock | undefined> {
-  const fill = {
-    ..._.cloneDeep(_fill),
-    fromLiteChain: matchedDeposit.fromLiteChain,
-  };
+  const fill = _.cloneDeep(_fill);
 
   // Slow fills don't result in repayments so they're always valid.
   if (isSlowFill(fill)) {
     return fill;
   }
 
-  let repaymentChainId = _getRepaymentChainId(fill, hubPoolClient, bundleEndBlockForMainnet);
+  let repaymentChainId = getRepaymentChainId(fill, matchedDeposit);
+
+  // If repayment chain doesn't have a Pool Rebalance Route for the input token, then change the repayment
+  // chain to the destination chain.
+  if (forceDestinationRepayment(repaymentChainId, matchedDeposit, hubPoolClient)) {
+    repaymentChainId = fill.destinationChainId;
+  }
 
-  // Repayments will always go to the fill.relayer address so check if its a valid EVM address. If its not, attempt
-  // to change it to the msg.sender of the FilledRelay.
-  if (_repaymentAddressNeedsToBeOverwritten(fill)) {
+  if (!isValidEvmAddress(fill.relayer)) {
     // TODO: Handle case where fill was sent on non-EVM chain, in which case the following call would fail
     // or return something unexpected. We'd want to return undefined here.
-
-    // @todo: If chainIsEvm:
     const fillTransaction = await destinationChainProvider.getTransaction(fill.transactionHash);
     const destinationRelayer = fillTransaction?.from;
     // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
     if (!isDefined(destinationRelayer) || !isValidEvmAddress(destinationRelayer)) {
       return undefined;
     }
-    // If we can switch the repayment chain to the destination chain, then do so. We should only switch if the
-    // destination chain has a valid repayment token that is equivalent to the deposited input token. This would
-    // also be the same mapping as the repayment token on the repayment chain.
-    if (
-      !matchedDeposit.fromLiteChain &&
-      hubPoolClient.areTokensEquivalent(fill.inputToken, fill.originChainId, fill.outputToken, fill.destinationChainId)
-    ) {
+    if (!matchedDeposit.fromLiteChain) {
       repaymentChainId = fill.destinationChainId;
-    }
-    // If we can't switch the chain, then we need to verify that the msg.sender is a valid address on the repayment chain.
-    // Because we already checked that the `destinationRelayer` was a valid EVM address above, we only need to check
-    // that the repayment chain is an EVM chain.
-    else {
+    } else {
+      // We can't switch repayment chain for a lite chain deposit so just check whether the repayment chain,
+      // which should be the origin chain, is an EVM chain.
       if (!chainIsEvm(repaymentChainId)) {
         return undefined;
       }
     }
     fill.relayer = destinationRelayer;
-
-    // @todo: If chainIsSvm:
   }
 
   // Repayment address is now valid and repayment chain is either origin chain for lite chain or the destination
@@ -122,69 +126,3 @@ export async function verifyFillRepayment(
   fill.repaymentChainId = repaymentChainId;
   return fill;
 }
-
-function _getRepaymentChainId(
-  relayData: FillRepaymentInformation,
-  hubPoolClient: HubPoolClient,
-  bundleEndBlockForMainnet: number
-): number {
-  if (relayData.fromLiteChain) {
-    assert(!isSlowFill(relayData), "getRepaymentChainId: fromLiteChain and slow fill are mutually exclusive");
-    return relayData.originChainId;
-  }
-
-  // Handle slow relay where FilledRelay.repaymentChainId = 0, as hardcoded in the SpokePool contract.
-  // Slow relays always pay recipient on destination chain.
-  if (isSlowFill(relayData)) {
-    return relayData.destinationChainId;
-  }
-
-  // Repayment chain is valid if the input token and repayment chain are mapped to the same PoolRebalanceRoute.
-  const repaymentTokenIsValid = _repaymentChainTokenIsValid(relayData, hubPoolClient, bundleEndBlockForMainnet);
-  if (repaymentTokenIsValid) {
-    return relayData.repaymentChainId;
-  }
-
-  // If repayment chain is not valid, default to origin chain since we always know the input token can be refunded.
-  return relayData.originChainId;
-}
-
-function _repaymentChainTokenIsValid(
-  relayData: FillRepaymentInformation,
-  hubPoolClient: HubPoolClient,
-  bundleEndBlockForMainnet: number
-): boolean {
-  if (
-    !hubPoolClient.l2TokenHasPoolRebalanceRoute(relayData.inputToken, relayData.originChainId, bundleEndBlockForMainnet)
-  ) {
-    return false;
-  }
-  const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-    relayData.inputToken,
-    relayData.originChainId,
-    bundleEndBlockForMainnet
-  );
-  if (
-    !hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
-      l1TokenCounterpart,
-      relayData.repaymentChainId,
-      bundleEndBlockForMainnet
-    )
-  ) {
-    return false;
-  }
-  return true;
-}
-
-function _repaymentAddressNeedsToBeOverwritten(fill: Fill): boolean {
-  // Slow fills don't result in repayments so they're always valid.
-  if (isSlowFill(fill)) {
-    return false;
-  }
-
-  // @todo add Solana logic here:
-  // - i.e. If chainIsSvm && !isValidSvmAddress(fill.relayer) then return false
-  //        If chainIsEvm && !isValidEvmAddress(fill.relayer) then return false
-  //        If chainIsEvm && isValidEvmAddress(fill.relayer) then return true
-  return !isValidEvmAddress(fill.relayer);
-}

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -163,13 +163,12 @@ export function updateRunningBalanceForDeposit(
   runningBalances: RunningBalances,
   hubPoolClient: HubPoolClient,
   deposit: V3DepositWithBlock,
-  updateAmount: BigNumber,
-  mainnetBundleEndBlock: number
+  updateAmount: BigNumber
 ): void {
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
     deposit.inputToken,
     deposit.originChainId,
-    mainnetBundleEndBlock
+    deposit.quoteBlockNumber
   );
   updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart, updateAmount);
 }

package/src/clients/HubPoolClient.ts

@@ -43,7 +43,6 @@ import {
   toBN,
   getTokenInfo,
   getUsdcSymbol,
-  getL1TokenInfo,
   compareAddressesSimple,
 } from "../utils";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "./AcrossConfigStoreClient/AcrossConfigStoreClient";
@@ -231,39 +230,38 @@ export class HubPoolClient extends BaseAbstractClient {
     return sortEventsDescending(l2Tokens)[0].l1Token;
   }
 
-  protected getL1TokenForDeposit(
-    deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
-  ): string {
+  /**
+   * Returns the L1 token that should be used for an L2 Bridge event. This function is
+   * designed to be used by the caller to associate the L2 token with its mapped L1 token
+   * at the HubPool equivalent block number of the L2 event.
+   * @param deposit Deposit event
+   * @param returns string L1 token counterpart for Deposit
+   */
+  getL1TokenForDeposit(deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">): string {
     // L1-->L2 token mappings are set via PoolRebalanceRoutes which occur on mainnet,
     // so we use the latest token mapping. This way if a very old deposit is filled, the relayer can use the
     // latest L2 token mapping to find the L1 token counterpart.
     return this.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
   }
 
-  l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean {
-    return this.l1TokensToDestinationTokens?.[l1Token]?.[destinationChainId] != undefined;
-  }
-
-  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
-    // Find the last mapping published before the target block.
-    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
-      this.l1TokensToDestinationTokensWithBlock?.[l1Token]?.[destinationChainId] ?? []
-    ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
-    return l2Token !== undefined;
+  /**
+   * Returns the L2 token that should be used as a counterpart to a deposit event. For example, the caller
+   * might want to know what the refund token will be on l2ChainId for the deposit event.
+   * @param l2ChainId Chain where caller wants to get L2 token counterpart for
+   * @param event Deposit event
+   * @returns string L2 token counterpart on l2ChainId
+   */
+  getL2TokenForDeposit(
+    deposit: Pick<DepositWithBlock, "originChainId" | "destinationChainId" | "inputToken" | "quoteBlockNumber">,
+    l2ChainId = deposit.destinationChainId
+  ): string {
+    const l1Token = this.getL1TokenForDeposit(deposit);
+    // Use the latest hub block number to find the L2 token counterpart.
+    return this.getL2TokenForL1TokenAtBlock(l1Token, l2ChainId, deposit.quoteBlockNumber);
   }
 
-  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestBlockSearched): boolean {
-    return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
-      return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
-        return setPoolRebalanceRouteEvents.some((e) => {
-          return (
-            e.blockNumber <= hubPoolBlock &&
-            compareAddressesSimple(e.l2Token, l2Token) &&
-            Number(_l2ChainId) === l2ChainId
-          );
-        });
-      });
-    });
+  l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean {
+    return this.l1TokensToDestinationTokens?.[l1Token]?.[destinationChainId] != undefined;
   }
 
   /**
@@ -282,17 +280,6 @@ export class HubPoolClient extends BaseAbstractClient {
     return tokenInfo;
   }
 
-  /**
-   * @dev If tokenAddress + chain do not exist in TOKEN_SYMBOLS_MAP then this will throw.
-   * @dev if the token matched in TOKEN_SYMBOLS_MAP does not have an L1 token address then this will throw.
-   * @param tokenAddress Token address on `chain`
-   * @param chain Chain where the `tokenAddress` exists in TOKEN_SYMBOLS_MAP.
-   * @returns Token info for the given token address on the Hub chain including symbol and decimal and L1 address.
-   */
-  getL1TokenInfoForAddress(tokenAddress: string, chain: number): L1Token {
-    return getL1TokenInfo(tokenAddress, chain);
-  }
-
   /**
    * Resolve a given timestamp to a block number on the HubPool chain.
    * @param timestamp A single timestamp to be resolved to a block number on the HubPool chain.
@@ -512,17 +499,6 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.getTokenInfoForL1Token(l1TokenCounterpart);
   }
 
-  getTokenInfoForDeposit(deposit: Pick<Deposit, "inputToken" | "originChainId">): L1Token | undefined {
-    return this.getTokenInfoForL1Token(
-      this.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, this.latestBlockSearched)
-    );
-  }
-
-  getTokenInfo(chainId: number | string, tokenAddress: string): L1Token | undefined {
-    const deposit = { originChainId: parseInt(chainId.toString()), inputToken: tokenAddress };
-    return this.getTokenInfoForDeposit(deposit);
-  }
-
   areTokensEquivalent(
     tokenA: string,
     chainIdA: number,
@@ -530,23 +506,21 @@ export class HubPoolClient extends BaseAbstractClient {
     chainIdB: number,
     hubPoolBlock = this.latestBlockSearched
   ): boolean {
-    if (
-      !this.l2TokenHasPoolRebalanceRoute(tokenA, chainIdA, hubPoolBlock) ||
-      !this.l2TokenHasPoolRebalanceRoute(tokenB, chainIdB, hubPoolBlock)
-    ) {
-      return false;
-    }
-    // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
-    const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
-    const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
-    if (l1TokenA !== l1TokenB) {
-      return false;
-    }
+    try {
+      // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
+      const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
+      const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
+      if (l1TokenA !== l1TokenB) {
+        return false;
+      }
 
-    // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
-    const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
-    const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
-    return tokenA === _tokenA && tokenB === _tokenB;
+      // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
+      const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
+      const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
+      return tokenA === _tokenA && tokenB === _tokenB;
+    } catch {
+      return false; // One or both input tokens were not recognised.
+    }
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -17,7 +17,6 @@ import {
   isZeroAddress,
   toAddress,
   validateFillForDeposit,
-  chainIsEvm,
 } from "../../utils";
 import {
   duplicateEvent,
@@ -42,7 +41,7 @@ import {
 } from "../../interfaces";
 import { BaseAbstractClient, UpdateFailureReason } from "../BaseAbstractClient";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
-import { getRefundInformationFromFill } from "../BundleDataClient";
+import { getRepaymentChainId, forceDestinationRepayment } from "../BundleDataClient";
 import { HubPoolClient } from "../HubPoolClient";
 
 export type SpokePoolUpdateSuccess = {
@@ -366,25 +365,22 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         fill: FillWithBlock
       ) => {
         if (validateFillForDeposit(fill, deposit).valid) {
-          const fillRepaymentData = {
-            ...fill,
-            fromLiteChain: deposit.fromLiteChain,
-          };
-          const { chainToSendRefundTo: repaymentChainId } = getRefundInformationFromFill(
-            fillRepaymentData,
-            this.hubPoolClient!,
-            this.hubPoolClient!.latestBlockSearched
-          );
-          // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills where
-          // the filler-specified repayment chain and repayment address is not a valid repayment upon
-          // first glance. In other words, the repayment address is not a valid EVM address or the repayment chain
-          // is not a valid EVM chain. In the case where the repayment address is not a valid EVM address, the dataworker
-          // might be able to overwrite the repayment address to the msg.sender on the fill txn, but to keep this
-          // functioon synchronous, we can't make that decision now. So this function might log some false positives.
+          const repaymentChainId = getRepaymentChainId(fill, deposit);
+          // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills that
+          // we'll have to overwrite repayment information for. This includes fills for lite chains where the
+          // repayment address is invalid, and fills for non-lite chains where the repayment address is valid or
+          // the repayment chain is invalid. We don't check that the origin chain is a valid EVM chain for
+          // lite chain deposits yet because only EVM chains are supported on Across...for now. This means
+          // this logic will have to be revisited when we add SVM to log properly.
           if (
             this.hubPoolClient &&
             !isSlowFill(fill) &&
-            (!chainIsEvm(repaymentChainId) || !isValidEvmAddress(fill.relayer))
+            (!isValidEvmAddress(fill.relayer) ||
+              forceDestinationRepayment(
+                repaymentChainId,
+                { ...deposit, quoteBlockNumber: this.hubPoolClient!.latestBlockSearched },
+                this.hubPoolClient
+              ))
           ) {
             groupedFills.unrepayableFills.push(fill);
           }
@@ -454,29 +450,6 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     return `${event.depositId.toString()}-${event.originChainId}`;
   }
 
-  protected canResolveZeroAddressOutputToken(deposit: DepositWithBlock): boolean {
-    if (
-      !this.hubPoolClient?.l2TokenHasPoolRebalanceRoute(
-        deposit.inputToken,
-        deposit.originChainId,
-        deposit.quoteBlockNumber
-      )
-    ) {
-      return false;
-    } else {
-      const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
-        deposit.inputToken,
-        deposit.originChainId,
-        deposit.quoteBlockNumber
-      );
-      return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
-        l1Token,
-        deposit.destinationChainId,
-        deposit.quoteBlockNumber
-      );
-    }
-  }
-
   /**
    * A wrapper over the `_update` method that handles errors and logs. This method additionally calls into the
    * HubPoolClient to update the state of this client with data from the HubPool contract.
@@ -736,19 +709,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @returns The destination token.
    */
   protected getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
-    if (!this.canResolveZeroAddressOutputToken(deposit)) {
-      return ZERO_ADDRESS;
-    }
-    // L1 token should be resolved if we get here:
-    const l1Token = this.hubPoolClient!.getL1TokenForL2TokenAtBlock(
-      deposit.inputToken,
-      deposit.originChainId,
-      deposit.quoteBlockNumber
-    )!;
-    return (
-      this.hubPoolClient!.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber) ??
-      ZERO_ADDRESS
-    );
+    // If there is no rate model client return address(0).
+    return this.hubPoolClient?.getL2TokenForDeposit(deposit) ?? ZERO_ADDRESS;
   }
 
   /**

package/src/clients/mocks/MockHubPoolClient.ts

@@ -24,7 +24,7 @@ export class MockHubPoolClient extends HubPoolClient {
 
   private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
   private tokenInfoToReturn: L1Token = { address: "", decimals: 0, symbol: "" };
-
+  
   private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
 
   private eventManager: EventManager;
@@ -91,7 +91,7 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock;
   }
 
-  getTokenInfoForDeposit() {
+  getTokenInfoForAddress() {
     return this.tokenInfoToReturn;
   }
 
@@ -100,22 +100,6 @@ export class MockHubPoolClient extends HubPoolClient {
     this.spokePoolTokens[l1Token][chainId] = l2Token;
   }
 
-  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
-    if (this.spokePoolTokens[l1Token]?.[destinationChainId]) {
-      return true;
-    } else {
-      return super.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, hubBlockNumber);
-    }
-  }
-  l2TokenHasPoolRebalanceRoute(l2Token: string, chainId: number, hubPoolBlock: number): boolean {
-    const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
-    );
-    if (!l1Token) {
-      return super.l2TokenHasPoolRebalanceRoute(l2Token, chainId, hubPoolBlock);
-    } else return true;
-  }
-
   deleteTokenMapping(l1Token: string, chainId: number) {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }

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

@@ -252,14 +252,4 @@ export class QueryBase implements QueryInterface {
     );
     return price;
   }
-
-  /**
-   * Resolves the number of decimal places a token can have
-   * @param tokenSymbol A valid Across-Enabled Token ID
-   * @returns The number of decimals of precision for the corresponding tokenSymbol
-   */
-  getTokenDecimals(tokenSymbol: string): number {
-    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
-    return this.symbolMapping[tokenSymbol].decimals;
-  }
 }

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -34,7 +34,6 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getTokenDecimals: (tokenSymbol: string) => number;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];

package/src/utils/DepositUtils.ts

@@ -2,7 +2,7 @@ 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, isZeroAddress } from "./SpokeUtils";
+import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getNetworkName } from "./NetworkUtils";
 import { bnZero } from "./BigNumberUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
@@ -208,11 +208,6 @@ export function isZeroValueDeposit(deposit: Pick<Deposit, "inputAmount" | "messa
   return deposit.inputAmount.eq(0) && isMessageEmpty(deposit.message);
 }
 
-export function invalidOutputToken(deposit: Pick<DepositWithBlock, "outputToken">): boolean {
-  // If the output token is zero address, then it is invalid.
-  return isZeroAddress(deposit.outputToken);
-}
-
 export function isZeroValueFillOrSlowFillRequest(
   e: Pick<Fill | SlowFillRequest, "inputAmount" | "messageHash">
 ): boolean {

package/src/utils/TokenUtils.ts

@@ -147,6 +147,8 @@ export function getUsdcSymbol(l2Token: string, chainId: number): string | undefi
 }
 
 export function getL1TokenInfo(l2TokenAddress: string, chainId: number): L1Token {
+  if (chainId === CHAIN_IDs.MAINNET)
+    throw new Error("chainId should be an L2 chainId because many mappings re-use the same L1 token address");
   const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
   const l1TokenAddress = tokenObject?.addresses[CHAIN_IDs.MAINNET];
   if (!l1TokenAddress) {