@across-protocol/sdk 4.1.47 → 4.1.49

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,