@imtbl/sdk 0.27.9 → 0.27.11

package/dist/index.js

@@ -17,7 +17,8 @@ import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 import { parseUnits } from '@ethersproject/units';
 import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
 import detectEthereumProvider from '@metamask/detect-provider';
-import { TradeType, Token, CurrencyAmount, Percent } from '@uniswap/sdk-core';
+import * as Uniswap from '@uniswap/sdk-core';
+import { TradeType, Percent } from '@uniswap/sdk-core';
 import assert from 'assert';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
@@ -3609,7 +3610,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.9' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.11' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3669,7 +3670,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.9',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.11',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4080,7 +4081,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.9',
+    sdkVersion: 'ts-immutable-sdk-0.27.11',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8560,6 +8561,7 @@ var PassportErrorType;
     PassportErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
+    PassportErrorType["USER_NOT_REGISTERED_ERROR"] = "USER_NOT_REGISTERED_ERROR";
     PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
     PassportErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
     PassportErrorType["CREATE_ORDER_ERROR"] = "CREATE_ORDER_ERROR";
@@ -8709,6 +8711,10 @@ class AuthManager {
     config;
     deviceCredentialsManager;
     logoutMode;
+    /**
+     * Promise that is used to prevent multiple concurrent calls to the refresh token endpoint.
+     */
+    refreshingPromise = null;
     constructor(config) {
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
@@ -8953,32 +8959,52 @@ class AuthManager {
      * @param forceRefresh If set to true, force an HTTP call to the OIDC server's authorization endpoint. This call will
      * throw an error if there's no refresh token.
      */
-    async getWebUser({ forceRefresh = false }) {
+    async getAuthenticatedUser({ forceRefresh = false }) {
         if (forceRefresh) {
-            const newOidcUser = await this.userManager.signinSilent();
-            return newOidcUser ? AuthManager.mapOidcUserToDomainModel(newOidcUser) : null;
+            return this.refreshTokenAndUpdatePromise();
         }
         const oidcUser = await this.userManager.getUser();
         if (!oidcUser)
             return null;
-        const tokenExpired = isTokenExpired(oidcUser);
-        if (!tokenExpired) {
+        if (!isTokenExpired(oidcUser)) {
             return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }
         if (oidcUser.refresh_token) {
-            const newOidcUser = await this.userManager.signinSilent();
-            if (newOidcUser) {
-                return AuthManager.mapOidcUserToDomainModel(newOidcUser);
-            }
+            return this.refreshTokenAndUpdatePromise();
         }
         return null;
     }
+    /**
+     * Refreshes the token and returns the user.
+     * If the token is already being refreshed, returns the existing promise.
+     */
+    async refreshTokenAndUpdatePromise() {
+        if (this.refreshingPromise)
+            return this.refreshingPromise;
+        // eslint-disable-next-line no-async-promise-executor
+        this.refreshingPromise = new Promise(async (resolve, reject) => {
+            try {
+                const newOidcUser = await this.userManager.signinSilent();
+                if (newOidcUser) {
+                    resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
+                    return;
+                }
+                resolve(null);
+            }
+            catch (err) {
+                reject(err);
+            }
+            finally {
+                this.refreshingPromise = null; // Reset the promise after completion
+            }
+        });
+        return this.refreshingPromise;
+    }
     async getUser({ forceRefresh } = { forceRefresh: false }) {
         return withPassportError(async () => {
-            const user = await this.getWebUser({ forceRefresh });
-            if (user) {
+            const user = await this.getAuthenticatedUser({ forceRefresh });
+            if (user)
                 return user;
-            }
             const deviceToken = this.deviceCredentialsManager.getCredentials();
             if (deviceToken) {
                 return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
@@ -9005,14 +9031,16 @@ class MagicAdapter {
     magicClient;
     constructor(config) {
         this.config = config;
-        this.magicClient = new Magic(this.config.magicPublishableApiKey, {
-            extensions: [new OpenIdExtension()],
-            network: config.network,
-        });
-        this.magicClient.preload();
+        if (window) {
+            this.magicClient = this.initMagicClient();
+            this.magicClient.preload();
+        }
     }
     async login(idToken) {
         return withPassportError(async () => {
+            if (!this.magicClient) {
+                this.magicClient = this.initMagicClient();
+            }
             await this.magicClient.openid.loginWithOIDC({
                 jwt: idToken,
                 providerId: this.config.magicProviderId,
@@ -9021,10 +9049,16 @@ class MagicAdapter {
         }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
     async logout() {
-        if (this.magicClient.user) {
+        if (this.magicClient?.user) {
             await this.magicClient.user.logout();
         }
     }
+    initMagicClient() {
+        return new Magic(this.config.magicPublishableApiKey, {
+            extensions: [new OpenIdExtension()],
+            network: this.config.network,
+        });
+    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -9111,16 +9145,13 @@ class GuardianClient {
     transactionAPI;
     messageAPI;
     confirmationScreen;
-    // TODO: ID-977, make this rollup agnostic
-    imxEtherAddress;
     crossSdkBridgeEnabled;
-    constructor({ accessToken, confirmationScreen, imxEtherAddress, config, }) {
-        const guardianConfiguration = new Configuration({ accessToken, basePath: config.imxPublicApiDomain });
+    constructor({ confirmationScreen, config }) {
+        const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
         this.confirmationScreen = confirmationScreen;
-        this.transactionAPI = new TransactionsApi(new Configuration(guardianConfiguration));
-        this.imxEtherAddress = imxEtherAddress;
         this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
         this.messageAPI = new MessagesApi(guardianConfiguration);
+        this.transactionAPI = new TransactionsApi(guardianConfiguration);
     }
     /**
      * Open confirmation screen and close it automatically if the
@@ -9144,29 +9175,30 @@ class GuardianClient {
     withDefaultConfirmationScreenTask(task) {
         return this.withConfirmationScreenTask()(task);
     }
-    async validate({ payloadHash }) {
+    async evaluateImxTransaction({ payloadHash, user }) {
         const finallyFn = () => {
             this.confirmationScreen.closeWindow();
         };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
             transactionID: payloadHash,
             chainType: 'starkex',
-        }), { finallyFn });
+        }, { headers }), { finallyFn });
         if (!transactionRes.data.id) {
             throw new Error("Transaction doesn't exists");
         }
-        const evaluateStarkexRes = await this.transactionAPI.evaluateTransaction({
+        const evaluateImxRes = await this.transactionAPI.evaluateTransaction({
             id: payloadHash,
             transactionEvaluationRequest: {
                 chainType: 'starkex',
             },
-        });
-        const { confirmationRequired } = evaluateStarkexRes.data;
+        }, { headers });
+        const { confirmationRequired } = evaluateImxRes.data;
         if (confirmationRequired) {
             if (this.crossSdkBridgeEnabled) {
                 throw new Error(transactionRejectedCrossSdkBridgeError);
             }
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
             if (!confirmationResult.confirmed) {
                 throw new Error('Transaction rejected by user');
             }
@@ -9210,7 +9242,7 @@ class GuardianClient {
             throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
         }
         if (confirmationRequired && !!transactionId) {
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
             if (!confirmationResult.confirmed) {
                 throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
             }
@@ -9306,10 +9338,7 @@ async function createOrder$1({ starkSigner, user, request, ordersApi, guardianCl
         const { ethAddress } = user.imx;
         const amountSell = request.sell.type === ERC721$1 ? '1' : request.sell.amount;
         const amountBuy = request.buy.type === ERC721$1 ? '1' : request.buy.amount;
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const getSignableOrderRequestV3 = {
             user: ethAddress,
             amount_buy: amountBuy,
@@ -9323,7 +9352,8 @@ async function createOrder$1({ starkSigner, user, request, ordersApi, guardianCl
         const getSignableOrderResponse = await ordersApi.getSignableOrder({
             getSignableOrderRequestV3,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableOrderResponse.data;
@@ -9365,7 +9395,8 @@ async function cancelOrder$1({ user, starkSigner, request, ordersApi, guardianCl
         const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
             getSignableCancelOrderRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableCancelOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
@@ -9428,7 +9459,8 @@ async function createTrade$1({ request, tradesApi, user, starkSigner, guardianCl
         const getSignableTradeResponse = await tradesApi.getSignableTrade({
             getSignableTradeRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableTradeResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableTradeResponse.data;
@@ -9475,7 +9507,8 @@ async function transfer$1({ request, transfersApi, starkSigner, user, guardianCl
         const signableResult = await transfersApi.getSignableTransferV1({
             getSignableTransferRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: signableResult.data.payload_hash,
         });
         const signableResultData = signableResult.data;
@@ -9522,14 +9555,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
             sender_ether_key: ethAddress,
             signable_requests: signableRequests,
         };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const signableResult = await transfersApi.getSignableTransfer({
             getSignableTransferRequestV2,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: signableResult.data.signable_responses[0]?.payload_hash,
         });
         const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
@@ -9559,39 +9590,40 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
 }
 
 class PassportImxProvider {
-    user;
+    authManager;
     starkSigner;
     immutableXClient;
-    confirmationScreen;
     guardianClient;
-    constructor({ user, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
-        this.user = user;
+    constructor({ authManager, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
+        this.authManager = authManager;
         this.starkSigner = starkSigner;
         this.immutableXClient = immutableXClient;
-        this.confirmationScreen = confirmationScreen;
         this.guardianClient = new GuardianClient({
-            accessToken: user.accessToken,
             confirmationScreen,
-            imxEtherAddress: user.imx.ethAddress,
             config,
         });
         passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
     }
     handleLogout = () => {
-        this.user = undefined;
         this.starkSigner = undefined;
     };
-    checkIsLoggedIn() {
-        if (this.user === undefined || this.starkSigner === undefined) {
+    async getAuthenticatedUserSigner() {
+        const user = await this.authManager.getUser();
+        if (!user || this.starkSigner === undefined) {
             throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
         }
+        const isUserImx = (oidcUser) => oidcUser?.imx !== undefined;
+        if (!isUserImx(user)) {
+            throw new PassportError('User has not been registered with StarkEx', PassportErrorType.USER_NOT_REGISTERED_ERROR);
+        }
+        return { user, starkSigner: this.starkSigner };
     }
     async transfer(request) {
-        this.checkIsLoggedIn();
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return transfer$1({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
             guardianClient: this.guardianClient,
         });
@@ -9606,52 +9638,52 @@ class PassportImxProvider {
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    createOrder(request) {
-        this.checkIsLoggedIn();
+    async createOrder(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return createOrder$1({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
             guardianClient: this.guardianClient,
         });
     }
-    cancelOrder(request) {
-        this.checkIsLoggedIn();
+    async cancelOrder(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return cancelOrder$1({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
             guardianClient: this.guardianClient,
         });
     }
-    createTrade(request) {
-        this.checkIsLoggedIn();
+    async createTrade(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return createTrade$1({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             tradesApi: this.immutableXClient.tradesApi,
             guardianClient: this.guardianClient,
         });
     }
-    batchNftTransfer(request) {
-        this.checkIsLoggedIn();
+    async batchNftTransfer(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return batchNftTransfer({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
             guardianClient: this.guardianClient,
         });
     }
-    exchangeTransfer(request) {
-        this.checkIsLoggedIn();
+    async exchangeTransfer(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return exchangeTransfer$1({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             exchangesApi: this.immutableXClient.exchangeApi,
         });
     }
@@ -9674,9 +9706,9 @@ class PassportImxProvider {
     token) {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    getAddress() {
-        this.checkIsLoggedIn();
-        return Promise.resolve(this.user.imx.ethAddress);
+    async getAddress() {
+        const { user } = await this.getAuthenticatedUserSigner();
+        return Promise.resolve(user.imx.ethAddress);
     }
 }
 
@@ -9730,9 +9762,9 @@ class PassportImxProviderFactory {
         const ethSigner = web3Provider.getSigner();
         const starkSigner = await getStarkSigner(ethSigner);
         if (!user.imx?.ethAddress) {
-            const userImx = await this.registerStarkEx(ethSigner, starkSigner, user.accessToken);
+            await this.registerStarkEx(ethSigner, starkSigner, user.accessToken);
             return new PassportImxProvider({
-                user: userImx,
+                authManager: this.authManager,
                 starkSigner,
                 immutableXClient: this.immutableXClient,
                 confirmationScreen: this.confirmationScreen,
@@ -9741,7 +9773,7 @@ class PassportImxProviderFactory {
             });
         }
         return new PassportImxProvider({
-            user: user,
+            authManager: this.authManager,
             starkSigner,
             immutableXClient: this.immutableXClient,
             confirmationScreen: this.confirmationScreen,
@@ -10486,9 +10518,7 @@ class ZkEvmProvider {
                     user: this.user,
                 });
                 this.guardianClient = new GuardianClient({
-                    accessToken: this.user.accessToken,
                     confirmationScreen: this.confirmationScreen,
-                    imxEtherAddress: this.user.zkEvm.ethAddress,
                     config: this.config,
                 });
                 this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
@@ -27978,13 +28008,14 @@ const quoteReturnMapping = {
  * @param poolB the other pool
  */
 function poolEquals(poolA, poolB) {
-    return (poolA === poolB
-        || (poolA.token0.equals(poolB.token0)
-            && poolA.token1.equals(poolB.token1)
-            && poolA.fee === poolB.fee));
+    return (poolA === poolB ||
+        (poolA.token0.equals(poolB.token0) && poolA.token1.equals(poolB.token1) && poolA.fee === poolB.fee));
 }
-async function getERC20Decimals(tokenAddress, provider) {
-    const decimalsFunctionSig = ethers.utils.id('decimals()').substring(0, 10);
+const decimalsFunctionSig = ethers.utils.id('decimals()').substring(0, 10);
+async function getTokenDecimals(tokenAddress, provider, nativeToken) {
+    if (tokenAddress === 'native') {
+        return nativeToken.decimals;
+    }
     try {
         const decimalsResult = await provider.call({
             to: tokenAddress,
@@ -28012,9 +28043,10 @@ function isValidNonZeroAddress(address) {
         return false;
     }
 }
+const isValidTokenLiteral = (address) => address === 'native' ? true : isValidNonZeroAddress(address);
 const erc20ToUniswapToken = (token) => 
 // eslint-disable-next-line implicit-arrow-linebreak
-new Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
+new Uniswap.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
 const uniswapTokenToERC20 = (token) => ({
     chainId: token.chainId,
     address: token.address,
@@ -28025,7 +28057,7 @@ const uniswapTokenToERC20 = (token) => ({
 });
 const toCurrencyAmount = (amount) => {
     const token = erc20ToUniswapToken(amount.token);
-    return CurrencyAmount.fromRawAmount(token, amount.value.toString());
+    return Uniswap.CurrencyAmount.fromRawAmount(token, amount.value.toString());
 };
 const newAmount = (amount, token) => ({
     value: amount,
@@ -28071,6 +28103,28 @@ const subtractAmount = (a, b) => {
     }
     throw new Error('Token mismatch: token types must be the same');
 };
+/**
+ * Converts our internal token type which could be ERC20 or Native
+ * into a format consumable by Checkout. They require an address to be
+ * present. We populate the address with empty string if it's Native.
+ * If it's ERC20, we don't need to change it.
+ */
+const toPublicTokenType = (token) => {
+    if (token.type === 'native') {
+        return {
+            address: '',
+            chainId: token.chainId,
+            decimals: token.decimals,
+            symbol: token.symbol,
+            name: token.name,
+        };
+    }
+    return token;
+};
+const toPublicAmount = (amount) => ({
+    token: toPublicTokenType(amount.token),
+    value: amount.value,
+});
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
@@ -28444,12 +28498,13 @@ const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAmount, spenderAd
         from: ownerAddress,
     };
 };
-const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, contracts, secondaryFees) => {
-    const amountOfTokenIn = tradeType === TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
-    const spender = secondaryFees.length === 0
-        ? contracts.routerAddress
-        : contracts.secondaryFeeAddress;
-    return { spender, amount: amountOfTokenIn };
+const prepareApproval = (tradeType, userSpecifiedAmount, quotedAmountWithSlippage, contracts, secondaryFees) => {
+    const amountInToApprove = tradeType === TradeType.EXACT_INPUT ? userSpecifiedAmount : quotedAmountWithSlippage;
+    if (!isERC20Amount(amountInToApprove)) {
+        return null;
+    }
+    const spender = secondaryFees.length === 0 ? contracts.routerAddress : contracts.secondaryFeeAddress;
+    return { spender, amount: amountInToApprove };
 };
 /**
  * Get an unsigned approval transaction if needed
@@ -28481,7 +28536,7 @@ async function getApproveGasEstimate(provider, ownerAddress, spenderAddress, tok
         from: ownerAddress,
     });
 }
-const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice, nativeTokenService) => {
+const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) => {
     const approveTransaction = await getApproveTransaction(provider, ownerAddress, preparedApproval.amount, preparedApproval.spender);
     if (!approveTransaction) {
         return null;
@@ -28490,11 +28545,42 @@ const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice, n
     const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, gasEstimate) : null;
     return {
         transaction: approveTransaction,
-        // TODO: TP-1649: Remove the wrapping here
-        gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
+        gasFeeEstimate: gasFeeEstimate ? toPublicAmount(gasFeeEstimate) : null,
     };
 };
 
+const canUnwrapToken = (token) => token.type === 'native';
+class NativeTokenService {
+    nativeToken;
+    wrappedToken;
+    constructor(nativeToken, wrappedToken) {
+        this.nativeToken = nativeToken;
+        this.wrappedToken = wrappedToken;
+    }
+    wrapAmount(amount) {
+        if (!canUnwrapToken(amount.token)) {
+            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
+        }
+        return newAmount(amount.value, this.wrappedToken);
+    }
+    unwrapAmount(amount) {
+        const isWrappedToken = amount.token.address.toLowerCase() !== this.wrappedToken.address.toLowerCase();
+        if (isWrappedToken) {
+            throw new Error(`cannot unwrap non-wrapped token ${amount.token.address}`);
+        }
+        return newAmount(amount.value, this.nativeToken);
+    }
+    maybeWrapToken(token) {
+        if (canUnwrapToken(token)) {
+            return this.wrappedToken;
+        }
+        return token;
+    }
+    maybeWrapAmount(amount) {
+        return newAmount(amount.value, this.maybeWrapToken(amount.token));
+    }
+}
+
 // slippageToPercent takes the slippage as a percentage (e.g. 0.1) and
 // converts it to the Uniswap equivalent type
 const slippageToFraction = (slippage) => {
@@ -28514,11 +28600,11 @@ const slippageToFraction = (slippage) => {
     return new Percent(numerator, denominator);
 };
 
-function getQuoteAmountFromTradeType(tradeInfo) {
-    if (tradeInfo.tradeType === TradeType.EXACT_INPUT) {
-        return tradeInfo.amountOut;
+function getQuoteAmountFromTradeType(routerQuote) {
+    if (routerQuote.tradeType === TradeType.EXACT_INPUT) {
+        return routerQuote.amountOut;
     }
-    return tradeInfo.amountIn;
+    return routerQuote.amountIn;
 }
 function applySlippage(tradeType, amount, slippage) {
     const slippageTolerance = slippageToFraction(slippage);
@@ -28527,22 +28613,18 @@ function applySlippage(tradeType, amount, slippage) {
     const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
     return ethers.BigNumber.from(amountWithSlippage.toString());
 }
-function prepareUserQuote(otherToken, tradeInfo, slippage, fees, nativeTokenService) {
-    const quote = getQuoteAmountFromTradeType(tradeInfo);
-    const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
+const prepareUserQuote = (nativeTokenService, routerQuote, slippage, tokenOfQuotedAmount) => {
+    const erc20QuoteAmount = getQuoteAmountFromTradeType(routerQuote);
+    // If the quote amount is the native token, we need to unwrap it if the user originally specified the native token
+    const quotedAmount = canUnwrapToken(tokenOfQuotedAmount)
+        ? nativeTokenService.unwrapAmount(erc20QuoteAmount)
+        : erc20QuoteAmount;
+    const quotedAmountWithMaxSlippage = newAmount(applySlippage(routerQuote.tradeType, quotedAmount.value, slippage), tokenOfQuotedAmount);
     return {
-        amount: quote,
-        amountWithMaxSlippage: {
-            token: otherToken,
-            value: amountWithSlippage,
-        },
-        slippage,
-        fees: fees.withAmounts().map((fee) => ({
-            ...fee,
-            amount: nativeTokenService.maybeWrapAmount(fee.amount),
-        })),
+        quotedAmount,
+        quotedAmountWithMaxSlippage,
     };
-}
+};
 function getOurQuoteReqAmount(amountSpecified, // the amount specified by the user, either exactIn or exactOut
 fees, tradeType, nativeTokenService) {
     if (tradeType === TradeType.EXACT_OUTPUT) {
@@ -28610,46 +28692,8 @@ class Fees {
     }
 }
 
-class NativeTokenService {
-    nativeToken;
-    wrappedToken;
-    constructor(nativeToken, wrappedToken) {
-        this.nativeToken = nativeToken;
-        this.wrappedToken = wrappedToken;
-    }
-    wrapAmount(amount) {
-        return newAmount(amount.value, this.wrappedToken);
-    }
-    unwrapAmount(amount) {
-        if (amount.token !== this.wrappedToken) {
-            throw new Error(`token ${amount.token.address} is not wrapped`);
-        }
-        return newAmount(amount.value, this.nativeToken);
-    }
-    maybeWrapToken(token) {
-        if (this.isNativeToken(token)) {
-            return this.wrappedToken;
-        }
-        return token;
-    }
-    maybeWrapAmount(amount) {
-        return newAmount(amount.value, this.maybeWrapToken(amount.token));
-    }
-    isNativeToken(token) {
-        return token === this.nativeToken;
-    }
-}
-
 const IMMUTABLE_TESTNET_RPC_URL = 'https://rpc.testnet.immutable.com';
 const IMMUTABLE_TESTNET_CHAIN_ID = 13472;
-
-const NATIVE_IMX_IMMUTABLE_TESTNET = {
-    chainId: IMMUTABLE_TESTNET_CHAIN_ID,
-    decimals: 18,
-    symbol: 'tIMX',
-    name: 'Immutable Testnet Token',
-    type: 'native',
-};
 const TIMX_IMMUTABLE_TESTNET = {
     chainId: IMMUTABLE_TESTNET_CHAIN_ID,
     address: '0x0000000000000000000000000000000000001010',
@@ -28679,7 +28723,9 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
         recipient: fee.recipient,
     }));
     if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [secondaryFeeValues, {
+        return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [
+            secondaryFeeValues,
+            {
                 tokenIn: route.tokenPath[0].address,
                 tokenOut: route.tokenPath[1].address,
                 fee: route.pools[0].fee,
@@ -28687,9 +28733,12 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
                 amountIn,
                 amountOutMinimum: amountOut,
                 sqrtPriceLimitX96: 0,
-            }]);
+            },
+        ]);
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [secondaryFeeValues, {
+    return secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [
+        secondaryFeeValues,
+        {
             tokenIn: route.tokenPath[0].address,
             tokenOut: route.tokenPath[1].address,
             fee: route.pools[0].fee,
@@ -28697,7 +28746,8 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
             amountInMaximum: amountIn,
             amountOut,
             sqrtPriceLimitX96: 0,
-        }]);
+        },
+    ]);
 }
 function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
     const path = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
@@ -28706,19 +28756,25 @@ function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn
         recipient: fee.recipient,
     }));
     if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [secondaryFeeValues, {
+        return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [
+            secondaryFeeValues,
+            {
                 path,
                 recipient: fromAddress,
                 amountIn,
                 amountOutMinimum: amountOut,
-            }]);
+            },
+        ]);
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [secondaryFeeValues, {
+    return secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [
+        secondaryFeeValues,
+        {
             path,
             recipient: fromAddress,
             amountInMaximum: amountIn,
             amountOut,
-        }]);
+        },
+    ]);
 }
 /**
  * Builds swap parameters
@@ -28743,7 +28799,10 @@ function buildSwapParameters(fromAddress, trade, options, secondaryFees, seconda
 function createSwapCallParametersWithFees(trade, fromAddress, swapOptions, secondaryFees) {
     const secondaryFeeContract = SecondaryFee__factory.createInterface();
     const swapWithFeesCalldata = buildSwapParameters(fromAddress, trade, swapOptions, secondaryFees, secondaryFeeContract);
-    return secondaryFeeContract.encodeFunctionData(multicallWithDeadlineFunctionSignature, [swapOptions.deadlineOrPreviousBlockhash, [swapWithFeesCalldata]]);
+    return secondaryFeeContract.encodeFunctionData(multicallWithDeadlineFunctionSignature, [
+        swapOptions.deadlineOrPreviousBlockhash,
+        [swapWithFeesCalldata],
+    ]);
 }
 function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees) {
     // Create an unchecked trade to be used in generating swap parameters.
@@ -28783,7 +28842,7 @@ function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouter
 const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
     if (ourQuote.tradeType === TradeType.EXACT_OUTPUT) {
         // when doing exact output, calculate the fees based on the amountIn
-        const amountToAdd = nativeTokenService.isNativeToken(fees.token)
+        const amountToAdd = canUnwrapToken(fees.token)
             ? nativeTokenService.unwrapAmount(ourQuote.amountIn)
             : ourQuote.amountIn;
         fees.addAmount(amountToAdd);
@@ -28827,7 +28886,7 @@ const SUPPORTED_SANDBOX_CHAINS = {
         rpcUrl: IMMUTABLE_TESTNET_RPC_URL,
         contracts: CONTRACTS_FOR_CHAIN_ID[IMMUTABLE_TESTNET_CHAIN_ID],
         commonRoutingTokens: IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS,
-        nativeToken: NATIVE_IMX_IMMUTABLE_TESTNET,
+        nativeToken: TIMX_IMMUTABLE_TESTNET,
         wrappedNativeToken: TIMX_IMMUTABLE_TESTNET, // TODO: TP-1649: Change to WIMX when ready.
     },
 };
@@ -28899,6 +28958,15 @@ class ExchangeConfiguration {
     }
 }
 
+const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
+    amount: toPublicAmount(amount),
+    amountWithMaxSlippage: toPublicAmount(amountWithMaxSlippage),
+    slippage,
+    fees: fees.withAmounts().map((fee) => ({
+        ...fee,
+        amount: toPublicAmount(fee.amount),
+    })),
+});
 class Exchange {
     provider;
     router;
@@ -28927,8 +28995,8 @@ class Exchange {
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
         assert(isValidNonZeroAddress(fromAddress), new InvalidAddressError('invalid from address'));
-        assert(isValidNonZeroAddress(tokenInAddress), new InvalidAddressError('invalid token in address'));
-        assert(isValidNonZeroAddress(tokenOutAddress), new InvalidAddressError('invalid token out address'));
+        assert(isValidTokenLiteral(tokenInAddress), new InvalidAddressError('invalid token in address'));
+        assert(isValidTokenLiteral(tokenOutAddress), new InvalidAddressError('invalid token out address'));
         assert(tokenInAddress.toLocaleLowerCase() !== tokenOutAddress.toLocaleLowerCase(), new DuplicateAddressesError());
         assert(maxHops <= MAX_MAX_HOPS, new InvalidMaxHopsError('max hops must be less than or equal to 10'));
         assert(maxHops >= MIN_MAX_HOPS, new InvalidMaxHopsError('max hops must be greater than or equal to 1'));
@@ -28946,63 +29014,63 @@ class Exchange {
         }
         return this.secondaryFees;
     }
-    async getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, amount, slippagePercent, maxHops, deadline, tradeType) {
-        Exchange.validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress);
+    parseTokenLiteral(tokenLiteral, decimals) {
+        if (tokenLiteral === 'native') {
+            return this.nativeToken;
+        }
+        return {
+            type: 'erc20',
+            address: tokenLiteral,
+            chainId: this.chainId,
+            decimals,
+        };
+    }
+    async getUnsignedSwapTx(fromAddress, tokenInLiteral, tokenOutLiteral, amount, slippagePercent, maxHops, deadline, tradeType) {
+        Exchange.validate(tokenInLiteral, tokenOutLiteral, maxHops, slippagePercent, fromAddress);
         // get the decimals of the tokens that will be swapped
         const [tokenInDecimals, tokenOutDecimals, secondaryFees] = await Promise.all([
-            getERC20Decimals(tokenInAddress, this.provider),
-            getERC20Decimals(tokenOutAddress, this.provider),
+            getTokenDecimals(tokenInLiteral, this.provider, this.nativeToken),
+            getTokenDecimals(tokenOutLiteral, this.provider, this.nativeToken),
             this.getSecondaryFees(),
         ]);
-        const tokenIn = {
-            type: 'erc20',
-            address: tokenInAddress,
-            chainId: this.chainId,
-            decimals: tokenInDecimals,
-        };
-        const tokenOut = {
-            type: 'erc20',
-            address: tokenOutAddress,
-            chainId: this.chainId,
-            decimals: tokenOutDecimals,
-        };
+        const tokenIn = this.parseTokenLiteral(tokenInLiteral, tokenInDecimals);
+        const tokenOut = this.parseTokenLiteral(tokenOutLiteral, tokenOutDecimals);
         // determine which amount was specified for the swap from the TradeType
         const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
         const amountSpecified = newAmount(amount, tokenSpecified);
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
-        // get quote and gas details
+        // Quotes will always use ERC20s. If the user-specified token is Native, we use the Wrapped Native Token pool
         const [ourQuote, gasPrice] = await Promise.all([
-            this.router.findOptimalRoute(ourQuoteReqAmount, otherToken, tradeType, maxHops),
+            this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops),
             fetchGasPrice(this.provider, this.nativeToken),
         ]);
         const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
         const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees, this.nativeTokenService);
-        const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees, this.nativeTokenService);
-        const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, {
+        const { quotedAmount, quotedAmountWithMaxSlippage } = prepareUserQuote(this.nativeTokenService, adjustedQuote, slippagePercent, otherToken);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, quotedAmountWithMaxSlippage, {
             routerAddress: this.routerContractAddress,
             secondaryFeeAddress: this.secondaryFeeContractAddress,
         }, secondaryFees);
         // preparedApproval always uses the tokenIn address because we are always selling the tokenIn
-        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice, this.nativeTokenService);
-        return {
-            approval,
-            swap,
-            quote: userQuote,
-        };
+        const approval = preparedApproval
+            ? await getApproval(this.provider, fromAddress, preparedApproval, gasPrice)
+            : null;
+        const quote = toPublicQuote(quotedAmount, quotedAmountWithMaxSlippage, slippagePercent, fees);
+        return { quote, approval, swap };
     }
     /**
      * Get the unsigned swap transaction given the amount to sell.
      * Includes quote details for the swap.
      *
-     * @param {string} fromAddress The public address that will sign and submit the transaction.
-     * @param {string} tokenInAddress Token address to sell.
-     * @param {string} tokenOutAddress Token address to buy.
-     * @param {ethers.BigNumberish} amountIn Amount to sell.
-     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0.
-     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2.
-     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes.
-     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap.
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress Token address or 'native' to sell
+     * @param {string} tokenOutAddress Token address or 'native' to buy
+     * @param {ethers.BigNumberish} amountIn Amount to sell in the smallest unit of the token-in
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
      */
     async getUnsignedSwapTxFromAmountIn(fromAddress, tokenInAddress, tokenOutAddress, amountIn, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = DEFAULT_DEADLINE) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.BigNumber.from(amountIn), slippagePercent, maxHops, deadline, TradeType.EXACT_INPUT);
@@ -29011,14 +29079,14 @@ class Exchange {
      * Get the unsigned swap transaction given the amount to buy.
      * Includes quote details for the swap.
      *
-     * @param {string} fromAddress The public address that will sign and submit the transaction.
-     * @param {string} tokenInAddress Token address to sell.
-     * @param {string} tokenOutAddress Token address to buy.
-     * @param {ethers.BigNumberish} amountOut Amount to buy.
-     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0.
-     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2.
-     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes.
-     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap.
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress ERC20 contract address or 'native' to sell
+     * @param {string} tokenOutAddress ERC20 contract address or 'native' to buy
+     * @param {ethers.BigNumberish} amountOut Amount to buy in the smallest unit of the token-out
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
      */
     async getUnsignedSwapTxFromAmountOut(fromAddress, tokenInAddress, tokenOutAddress, amountOut, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = DEFAULT_DEADLINE) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.BigNumber.from(amountOut), slippagePercent, maxHops, deadline, TradeType.EXACT_OUTPUT);
@@ -29262,6 +29330,14 @@ const $d85ad1457a3f1a83$export$fc55ed5a42b458ba = {
     [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET]: {
         url: "https://explorer.mainnet.immutable.com",
         nativeToken: $d85ad1457a3f1a83$export$6f24f3cef7d501c4.get(($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET).nativeCurrency
+    },
+    [($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA]: {
+        url: "https://eth-sepolia.blockscout.com",
+        nativeToken: $d85ad1457a3f1a83$export$3e81fc0987227f10.get(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA).nativeCurrency
+    },
+    [($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM]: {
+        url: "https://eth.blockscout.com/",
+        nativeToken: $d85ad1457a3f1a83$export$6f24f3cef7d501c4.get(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM).nativeCurrency
     }
 };
 const $d85ad1457a3f1a83$export$db5daa1b5156ccfe = [
@@ -29861,6 +29937,7 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async (config, { type: type =
 
 
 
+
 const $fd8a8472dcc3ec2b$var$CACHE_DATA_TTL = 60; // seconds
 class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
     url;
@@ -30033,18 +30110,23 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAdd
         type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC20_BALANCE_ERROR
     });
 }
-// Blockscout client singleton
-let $1564e43dde50bb61$var$blockscoutClient;
-const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, rename)=>{
+// Blockscout client singleton per chain id
+const $1564e43dde50bb61$var$blockscoutClientMap = new Map();
+const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, filterTokens)=>{
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
-    const mapRename = Object.assign({}, ...rename.map((t)=>({
+    const shouldFilter = filterTokens.length > 0;
+    const mapFilterTokens = Object.assign({}, ...filterTokens.map((t)=>({
             [t.address || ""]: t
         })));
-    // Ensure singleton is present and match the selected chain
-    if (!$1564e43dde50bb61$var$blockscoutClient || $1564e43dde50bb61$var$blockscoutClient.chainId !== chainId) $1564e43dde50bb61$var$blockscoutClient = new ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786)({
-        chainId: chainId
-    });
+    // Get blockscout client for the given chain
+    let blockscoutClient = $1564e43dde50bb61$var$blockscoutClientMap.get(chainId);
+    if (!blockscoutClient) {
+        blockscoutClient = new ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786)({
+            chainId: chainId
+        });
+        $1564e43dde50bb61$var$blockscoutClientMap.set(chainId, blockscoutClient);
+    }
     // Hold the items in an array for post-fetching processing
     const items = [];
     const tokenType = ($887a00f8f72d61f0$export$5bd1ea2b3d18210).ERC20;
@@ -30054,7 +30136,7 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
     try {
         do {
             // eslint-disable-next-line no-await-in-loop
-            resp = await $1564e43dde50bb61$var$blockscoutClient.getTokensByWalletAddress({
+            resp = await blockscoutClient.getTokensByWalletAddress({
                 walletAddress: walletAddress,
                 tokenType: tokenType,
                 nextPage: resp?.next_page_params
@@ -30072,7 +30154,7 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
         if (err?.code !== (HttpStatusCode$2).NotFound) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getTokensByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
     }
     try {
-        const respNative = await $1564e43dde50bb61$var$blockscoutClient.getNativeTokenByWalletAddress({
+        const respNative = await blockscoutClient.getNativeTokenByWalletAddress({
             walletAddress: walletAddress
         });
         items.push(respNative);
@@ -30086,24 +30168,26 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
         // or simply an incorrect wallet address was provided.
         if (err?.code !== (HttpStatusCode$2).NotFound) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getNativeTokenByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
     }
+    const balances = [];
+    items.forEach((item)=>{
+        if (shouldFilter && !mapFilterTokens[item.token.address]) return;
+        const tokenData = item.token || {};
+        const balance = (BigNumber$1).from(item.value);
+        let decimals = parseInt(tokenData.decimals, 10);
+        if (Number.isNaN(decimals)) decimals = ($d85ad1457a3f1a83$export$903389470ba9433c);
+        const token = {
+            ...tokenData,
+            decimals: decimals
+        };
+        const formattedBalance = (utils$1).formatUnits(item.value, token.decimals);
+        balances.push({
+            balance: balance,
+            formattedBalance: formattedBalance,
+            token: token
+        });
+    });
     return {
-        balances: items.map((item)=>{
-            const tokenData = item.token || {};
-            const balance = (BigNumber$1).from(item.value);
-            const renamed = mapRename[tokenData.address] || {};
-            const token = {
-                ...tokenData,
-                name: renamed.name ?? tokenData.name,
-                symbol: renamed.symbol ?? tokenData.symbol,
-                decimals: parseInt(tokenData.decimals, 10)
-            };
-            const formattedBalance = (utils$1).formatUnits(item.value, token.decimals);
-            return {
-                balance: balance,
-                formattedBalance: formattedBalance,
-                token: token
-            };
-        })
+        balances: balances
     };
 };
 const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, walletAddress, tokens)=>{
@@ -30134,7 +30218,15 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, w
         // eslint-disable-next-line no-console
         console.error(err);
     }
-    if (flag && ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786).isChainSupported(chainId)) return await $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, tokens);
+    if (flag && ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786).isChainSupported(chainId)) {
+        // This is a hack because the widgets are still using the tokens symbol
+        // to drive the conversions. If we remove all the token symbols from e.g. zkevm
+        // then we would not have fiat conversions.
+        // Please remove this hack once https://immutable.atlassian.net/browse/WT-1710
+        // is done.
+        const isL1Chain = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config) === chainId;
+        return await $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, isL1Chain ? tokens : []);
+    }
     // This fallback to use ERC20s calls which is a best effort solution
     // Fails in fetching data from the RCP calls might result in some
     // missing data.
@@ -33108,7 +33200,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         const tokenList = await $efe60cea83bfc4e8$export$473cec51305fdae8(this.config, {
             type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ONRAMP
         });
-        const token = tokenList.tokens.find((t)=>t.address?.toLowerCase() === params.tokenAddress?.toLowerCase());
+        const token = tokenList.tokens?.find((t)=>t.address?.toLowerCase() === params.tokenAddress?.toLowerCase());
         if (token) {
             tokenAmount = params.tokenAmount;
             tokenSymbol = token.symbol;
@@ -33181,7 +33273,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.9";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.11";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
@@ -33315,7 +33407,7 @@ var $207ed853f11d19d5$export$5a0ace85cae72d45;
     IMTBLWidgetEvents["IMTBL_SWAP_WIDGET_EVENT"] = "imtbl-swap-widget";
     IMTBLWidgetEvents["IMTBL_BRIDGE_WIDGET_EVENT"] = "imtbl-bridge-widget";
     IMTBLWidgetEvents["IMTBL_ONRAMP_WIDGET_EVENT"] = "imtbl-onramp-widget";
-    IMTBLWidgetEvents["IMTBL_PRIMARY_REVENUE_WIDGET_EVENT"] = "imtbl-sale-widget";
+    IMTBLWidgetEvents["IMTBL_SALE_WIDGET_EVENT"] = "imtbl-sale-widget";
 })($207ed853f11d19d5$export$5a0ace85cae72d45 || ($207ed853f11d19d5$export$5a0ace85cae72d45 = {}));