@across-protocol/sdk 4.1.47 → 4.1.48

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";
 
@@ -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}`);
     }
@@ -369,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/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,