@across-protocol/sdk 4.1.47-beta.0 → 4.1.48

package/dist/types/utils/TokenUtils.d.ts

@@ -68,6 +68,15 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    BNB: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     BOBA: {
         name: string;
         symbol: string;
@@ -77,6 +86,15 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    CAKE: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     DAI: {
         name: string;
         symbol: string;
@@ -222,6 +240,16 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    "USDC-BNB": {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        l1TokenDecimals: number;
+        coingeckoId: string;
+    };
     USDC: {
         name: string;
         symbol: string;
@@ -239,6 +267,12 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         addresses: {
             [x: number]: string;
         };
+        /**
+         * Get the USDC symbol for the given token address and chain ID.
+         * @param l2Token A Web3 token address (not case sensitive)
+         * @param chainId A chain Id to reference
+         * @returns Either USDC (if native) or USDbC/USDC.e (if bridged) or undefined if the token address is not recognized.
+         */
         coingeckoId: string;
     };
     USDbC: {
@@ -259,6 +293,16 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    "USDT-BNB": {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        l1TokenDecimals: number;
+        coingeckoId: string;
+    };
     USDT: {
         name: string;
         symbol: string;
@@ -268,6 +312,15 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    VLR: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     WAZERO: {
         name: string;
         symbol: string;
@@ -313,6 +366,15 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    WLD: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     WMATIC: {
         name: string;
         symbol: string;
@@ -342,7 +404,19 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         coingeckoId: string;
     };
 }) => string | undefined;
-export declare function getTokenInformationFromAddress(address: string, tokenMapping?: {
+export declare function getCoingeckoTokenIdByAddress(contractAddress: string, chainId: number): string;
+/**
+ * Retrieves the ERC20 balance for a given address and token address.
+ * @param address The address to retrieve the balance for.
+ * @param tokenAddress The token address
+ * @param signerOrProvider A valid ethers.js Signer or Provider object.
+ * @param blockTag The block tag to retrieve the balance at.
+ * @returns The balance of the given address for the given token address.
+ */
+export declare function getTokenBalance(address: string, tokenAddress: string, signerOrProvider: SignerOrProvider, blockTag?: BlockTag): Promise<BigNumber>;
+export declare function isBridgedUsdc(tokenSymbol: string): boolean;
+export declare function isStablecoin(tokenSymbol: string): boolean;
+export declare function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping?: {
     ACX: {
         name: string;
         symbol: string;
@@ -388,6 +462,15 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    BNB: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     BOBA: {
         name: string;
         symbol: string;
@@ -397,6 +480,15 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    CAKE: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     DAI: {
         name: string;
         symbol: string;
@@ -542,6 +634,16 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    "USDC-BNB": {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        l1TokenDecimals: number;
+        coingeckoId: string;
+    };
     USDC: {
         name: string;
         symbol: string;
@@ -559,6 +661,12 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         addresses: {
             [x: number]: string;
         };
+        /**
+         * Get the USDC symbol for the given token address and chain ID.
+         * @param l2Token A Web3 token address (not case sensitive)
+         * @param chainId A chain Id to reference
+         * @returns Either USDC (if native) or USDbC/USDC.e (if bridged) or undefined if the token address is not recognized.
+         */
         coingeckoId: string;
     };
     USDbC: {
@@ -579,6 +687,16 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    "USDT-BNB": {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        l1TokenDecimals: number;
+        coingeckoId: string;
+    };
     USDT: {
         name: string;
         symbol: string;
@@ -588,6 +706,15 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    VLR: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     WAZERO: {
         name: string;
         symbol: string;
@@ -633,6 +760,15 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
+    WLD: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     WMATIC: {
         name: string;
         symbol: string;
@@ -661,20 +797,7 @@ export declare function getTokenInformationFromAddress(address: string, tokenMap
         };
         coingeckoId: string;
     };
-}): L1Token | undefined;
-export declare function getCoingeckoTokenIdByAddress(contractAddress: string): string;
-/**
- * Retrieves the ERC20 balance for a given address and token address.
- * @param address The address to retrieve the balance for.
- * @param tokenAddress The token address
- * @param signerOrProvider A valid ethers.js Signer or Provider object.
- * @param blockTag The block tag to retrieve the balance at.
- * @returns The balance of the given address for the given token address.
- */
-export declare function getTokenBalance(address: string, tokenAddress: string, signerOrProvider: SignerOrProvider, blockTag?: BlockTag): Promise<BigNumber>;
-export declare function isBridgedUsdc(tokenSymbol: string): boolean;
-export declare function isStablecoin(tokenSymbol: string): boolean;
-export declare function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token;
+}): L1Token;
 /**
  * Get the USDC symbol for the given token address and chain ID.
  * @param l2Token A Web3 token address (not case sensitive)

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,GAAG,SAAS,CAWrH;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa/E"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkEjB;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MArEA,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoBlF;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAzBmG,GAAG,OAAO,CAkB/G;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAe/E"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.1.47-beta.0",
+  "version": "4.1.48",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -104,7 +104,7 @@
   },
   "dependencies": {
     "@across-protocol/across-token": "^1.0.0",
-    "@across-protocol/constants": "^3.1.51",
+    "@across-protocol/constants": "^3.1.57",
     "@across-protocol/contracts": "^4.0.5",
     "@coral-xyz/anchor": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",

package/src/clients/HubPoolClient.ts

@@ -43,7 +43,6 @@ import {
   toBN,
   getTokenInfo,
   getUsdcSymbol,
-  getL1TokenInfo,
   compareAddressesSimple,
   chainIsSvm,
   getDeployedAddress,
@@ -285,17 +284,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.
@@ -510,22 +498,6 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.lpTokens[l1Token];
   }
 
-  getL1TokenInfoForL2Token(l2Token: string, chainId: number): L1Token | undefined {
-    const l1TokenCounterpart = this.getL1TokenForL2TokenAtBlock(l2Token, chainId, this.latestBlockSearched);
-    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,

package/src/clients/mocks/MockHubPoolClient.ts

@@ -23,7 +23,6 @@ export class MockHubPoolClient extends HubPoolClient {
   private realizedLpFeePctOverride = false;
 
   private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
-  private tokenInfoToReturn: L1Token = { address: "", decimals: 0, symbol: "" };
 
   private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
 
@@ -91,10 +90,6 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock;
   }
 
-  getTokenInfoForDeposit() {
-    return this.tokenInfoToReturn;
-  }
-
   setTokenMapping(l1Token: string, chainId: number, l2Token: string) {
     this.spokePoolTokens[l1Token] ??= {};
     this.spokePoolTokens[l1Token][chainId] = l2Token;
@@ -136,10 +131,6 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock.find((token) => token.address === l1Token);
   }
 
-  setTokenInfoToReturn(tokenInfo: L1Token) {
-    this.tokenInfoToReturn = tokenInfo;
-  }
-
   _update(eventNames: string[]): Promise<HubPoolUpdate> {
     // Generate new "on chain" responses.
     const latestBlockSearched = this.eventManager.blockNumber;

package/src/coingecko/Coingecko.ts

@@ -131,7 +131,7 @@ export class Coingecko {
   protected async getCoingeckoTokenId(address: string, chainId: number): Promise<string> {
     let id: string | undefined;
     try {
-      id = getCoingeckoTokenIdByAddress(address);
+      id = getCoingeckoTokenIdByAddress(address, chainId);
 
       return id;
     } catch (error) {

package/src/constants.ts

@@ -8,6 +8,7 @@ export {
   PUBLIC_NETWORKS,
   TESTNET_CHAIN_IDs,
   TOKEN_SYMBOLS_MAP,
+  TOKEN_EQUIVALENCE_REMAPPING,
 } from "@across-protocol/constants";
 
 export const { AddressZero: ZERO_ADDRESS, HashZero: ZERO_BYTES } = ethersConstants;
@@ -64,6 +65,7 @@ export const BRIDGED_USDC_SYMBOLS = [
   TOKEN_SYMBOLS_MAP["USDC.e"].symbol,
   TOKEN_SYMBOLS_MAP.USDbC.symbol,
   TOKEN_SYMBOLS_MAP.USDzC.symbol,
+  TOKEN_SYMBOLS_MAP["USDC-BNB"].symbol,
 ];
 
 export const STABLE_COIN_SYMBOLS = [
@@ -80,6 +82,7 @@ export const STABLE_COIN_SYMBOLS = [
 ];
 
 export const CUSTOM_GAS_TOKENS = {
+  [CHAIN_IDs.BNB]: "BNB",
   [CHAIN_IDs.POLYGON]: "MATIC",
   [CHAIN_IDs.POLYGON_AMOY]: "MATIC",
   [CHAIN_IDs.ALEPH_ZERO]: "AZERO",

package/src/gasPriceOracle/oracle.ts

@@ -87,6 +87,7 @@ function _getEthersGasPriceEstimate(
   const gasPriceFeeds = {
     [CHAIN_IDs.ALEPH_ZERO]: arbitrum.eip1559,
     [CHAIN_IDs.ARBITRUM]: arbitrum.eip1559,
+    [CHAIN_IDs.BNB]: ethereum.eip1559,
     [CHAIN_IDs.MAINNET]: ethereum.eip1559,
     [CHAIN_IDs.POLYGON]: polygon.gasStation,
     [CHAIN_IDs.SCROLL]: ethereum.legacy,

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

@@ -8,7 +8,7 @@ import {
   TransactionCostEstimate,
   bnZero,
   fixedPointAdjustment,
-  getTokenInformationFromAddress,
+  getTokenInfo,
   isDefined,
   max,
   min,
@@ -16,6 +16,8 @@ import {
   percent,
   toBN,
   toBNWei,
+  isZeroAddress,
+  compareAddressesSimple,
 } from "../utils";
 import { Transport } from "viem";
 
@@ -34,7 +36,6 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getTokenDecimals: (tokenSymbol: string) => number;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -48,6 +49,7 @@ type ChainIdAsString = string;
 export interface CapitalCostConfigOverride {
   default: CapitalCostConfig;
   routeOverrides?: Record<ChainIdAsString, Record<ChainIdAsString, CapitalCostConfig>>;
+  destinationChainOverrides?: Record<ChainIdAsString, CapitalCostConfig>;
 }
 export type RelayCapitalCostConfig = CapitalCostConfigOverride | CapitalCostConfig;
 export interface BaseRelayFeeCalculatorConfig {
@@ -190,10 +192,10 @@ export class RelayFeeCalculator {
     this.validateCapitalCostsConfig(config.default);
     // Iterate over all the route overrides and validate them.
     for (const toChainIdRoutes of Object.values(config.routeOverrides || {})) {
-      for (const override of Object.values(toChainIdRoutes)) {
-        this.validateCapitalCostsConfig(override);
-      }
+      Object.values(toChainIdRoutes).forEach(this.validateCapitalCostsConfig);
     }
+    // Validate destination chain overrides
+    Object.values(config.destinationChainOverrides || {}).forEach(this.validateCapitalCostsConfig);
     return config;
   }
 
@@ -243,8 +245,20 @@ export class RelayFeeCalculator {
   ): Promise<BigNumber> {
     if (toBN(amountToRelay).eq(bnZero)) return MAX_BIG_INT;
 
-    const { inputToken } = deposit;
-    const token = getTokenInformationFromAddress(inputToken, tokenMapping);
+    const { inputToken, destinationChainId, originChainId } = deposit;
+    // It's fine if we resolve a destination token which is not the "canonical" L1 token (e.g. USDB for DAI or USDC.e for USDC), since `getTokenInfo` will re-map
+    // the output token to the canonical version. What matters here is that we find an entry in the token map which has defined addresses for BOTH the origin
+    // and destination chain. This prevents the call to `getTokenInfo` to mistakenly return token info for a token which has a defined address on origin and an
+    // undefined address on destination.
+    const destinationChainTokenDetails = Object.values(tokenMapping).find(
+      (details) =>
+        compareAddressesSimple(details.addresses[originChainId], inputToken) &&
+        isDefined(details.addresses[destinationChainId])
+    );
+    const outputToken = isZeroAddress(deposit.outputToken)
+      ? destinationChainTokenDetails!.addresses[destinationChainId]
+      : deposit.outputToken;
+    const token = getTokenInfo(outputToken, destinationChainId, tokenMapping);
     if (!isDefined(token)) {
       throw new Error(`Could not find token information for ${inputToken}`);
     }
@@ -311,10 +325,9 @@ export class RelayFeeCalculator {
     // bound to an upper bound. After the kink, the fee % increase will be fixed, and slowly approach the upper bound
     // for very large amount inputs.
     else {
-      const config =
-        isDefined(_originRoute) && isDefined(_destinationRoute)
-          ? tokenCostConfig.routeOverrides?.[_originRoute]?.[_destinationRoute] ?? tokenCostConfig.default
-          : tokenCostConfig.default;
+      const destinationChainOverride = tokenCostConfig?.destinationChainOverrides?.[_destinationRoute || ""];
+      const routeOverride = tokenCostConfig?.routeOverrides?.[_originRoute || ""]?.[_destinationRoute || ""];
+      const config: CapitalCostConfig = routeOverride ?? destinationChainOverride ?? tokenCostConfig.default;
 
       // Scale amount "y" to 18 decimals.
       const y = toBN(_amountToRelay).mul(toBNWei("1", 18 - config.decimals));
@@ -370,8 +383,10 @@ export class RelayFeeCalculator {
     // If the amount to relay is not provided, then we
     // should use the full deposit amount.
     amountToRelay ??= deposit.outputAmount;
-    const { inputToken } = deposit;
-    const token = getTokenInformationFromAddress(inputToken);
+    const { inputToken, originChainId } = deposit;
+    // We can perform a simple lookup with `getTokenInfo` here without resolving the exact token to resolve since we only need to
+    // resolve the L1 token symbol and not the L2 token decimals.
+    const token = getTokenInfo(inputToken, originChainId);
     if (!isDefined(token)) {
       throw new Error(`Could not find token information for ${inputToken}`);
     }

package/src/utils/EventUtils.ts

@@ -228,15 +228,9 @@ export function sortEventsAscending<T extends SortableEvent>(events: T[]): T[] {
 // This sorts the events in place, meaning it modifies the passed array and returns a reference to the same array.
 // Note: this method should only be used in cases where modifications are acceptable.
 export function sortEventsAscendingInPlace<T extends SortableEvent>(events: T[]): T[] {
-  return events.sort((ex, ey) => {
-    if (ex.blockNumber !== ey.blockNumber) {
-      return ex.blockNumber - ey.blockNumber;
-    }
-    if (ex.txnIndex !== ey.txnIndex) {
-      return ex.txnIndex - ey.txnIndex;
-    }
-    return ex.logIndex - ey.logIndex;
-  });
+  return events.sort((ex, ey) =>
+    ex.blockNumber === ey.blockNumber ? ex.logIndex - ey.logIndex : ex.blockNumber - ey.blockNumber
+  );
 }
 
 // This copies the array and sorts it, returning a new array with the new ordering.
@@ -247,26 +241,14 @@ export function sortEventsDescending<T extends SortableEvent>(events: T[]): T[]
 // This sorts the events in place, meaning it modifies the passed array and returns a reference to the same array.
 // Note: this method should only be used in cases where modifications are acceptable.
 export function sortEventsDescendingInPlace<T extends SortableEvent>(events: T[]): T[] {
-  return events.sort((ex, ey) => {
-    if (ex.blockNumber !== ey.blockNumber) {
-      return ey.blockNumber - ex.blockNumber;
-    }
-    if (ex.txnIndex !== ey.txnIndex) {
-      return ey.txnIndex - ex.txnIndex;
-    }
-    return ey.logIndex - ex.logIndex;
-  });
+  return events.sort((ex, ey) =>
+    ex.blockNumber === ey.blockNumber ? ey.logIndex - ex.logIndex : ey.blockNumber - ex.blockNumber
+  );
 }
 
 // Returns true if ex is older than ey.
 export function isEventOlder<T extends SortableEvent>(ex: T, ey: T): boolean {
-  if (ex.blockNumber !== ey.blockNumber) {
-    return ex.blockNumber < ey.blockNumber;
-  }
-  if (ex.txnIndex !== ey.txnIndex) {
-    return ex.txnIndex < ey.txnIndex;
-  }
-  return ex.logIndex < ey.logIndex;
+  return ex.blockNumber === ey.blockNumber ? ex.logIndex < ey.logIndex : ex.blockNumber < ey.blockNumber;
 }
 
 export function getTransactionRefs(events: SortableEvent[]): string[] {

package/src/utils/TokenUtils.ts

@@ -4,10 +4,10 @@ import * as constants from "../constants";
 import { L1Token } from "../interfaces";
 import { ERC20__factory } from "../typechain";
 import { BigNumber } from "./BigNumberUtils";
-import { getNetworkName } from "./NetworkUtils";
+import { getNetworkName, chainIsL1 } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
 import { compareAddressesSimple } from "./AddressUtils";
-const { TOKEN_SYMBOLS_MAP, CHAIN_IDs } = constants;
+const { TOKEN_SYMBOLS_MAP, CHAIN_IDs, TOKEN_EQUIVALENCE_REMAPPING } = constants;
 
 type SignerOrProvider = providers.Provider | Signer;
 
@@ -64,21 +64,8 @@ export const resolveContractFromSymbol = (
   })?.addresses[Number(chainId)];
 };
 
-export function getTokenInformationFromAddress(address: string, tokenMapping = TOKEN_SYMBOLS_MAP): L1Token | undefined {
-  const details = Object.values(tokenMapping).find((details) => {
-    return Object.values(details.addresses).some((t) => t.toLowerCase() === address.toLowerCase());
-  });
-  return isDefined(details)
-    ? {
-        decimals: details.decimals,
-        symbol: details.symbol,
-        address,
-      }
-    : undefined;
-}
-
-export function getCoingeckoTokenIdByAddress(contractAddress: string): string {
-  const token = getTokenInformationFromAddress(contractAddress);
+export function getCoingeckoTokenIdByAddress(contractAddress: string, chainId: number): string {
+  const token = getTokenInfo(contractAddress, chainId);
   if (!token) {
     throw new Error(`Token with address ${contractAddress} not found in token mapping`);
   }
@@ -115,15 +102,19 @@ export function isStablecoin(tokenSymbol: string): boolean {
   );
 }
 
-export function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token {
+export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): L1Token {
   // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
   // to get around this...
-  const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
+  let tokenObject = Object.values(tokenMapping).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
   if (!tokenObject) {
     throw new Error(
       `TokenUtils#getTokenInfo: Unable to resolve token in TOKEN_SYMBOLS_MAP for ${l2TokenAddress} on chain ${chainId}`
     );
   }
+  if (chainIsL1(chainId)) {
+    const l1TokenSymbol = TOKEN_EQUIVALENCE_REMAPPING[tokenObject.symbol] ?? tokenObject.symbol;
+    tokenObject = tokenMapping[l1TokenSymbol as keyof typeof tokenMapping];
+  }
   return {
     address: l2TokenAddress,
     symbol: tokenObject.symbol,
@@ -147,6 +138,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) {