@imtbl/sdk 0.27.8 → 0.27.10

package/dist/index.cjs

@@ -19,7 +19,7 @@ var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
 var detectEthereumProvider = require('@metamask/detect-provider');
-var sdkCore = require('@uniswap/sdk-core');
+var Uniswap = require('@uniswap/sdk-core');
 var assert = require('assert');
 var v3Sdk = require('@uniswap/v3-sdk');
 var solidity = require('@ethersproject/solidity');
@@ -46,6 +46,7 @@ function _interopNamespaceDefault(e) {
 
 var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
 var encUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(encUtils);
+var Uniswap__namespace = /*#__PURE__*/_interopNamespaceDefault(Uniswap);
 
 var Environment$1;
 (function (Environment) {
@@ -3631,7 +3632,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.8' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.27.10' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3691,7 +3692,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.8',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.10',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4102,7 +4103,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.8',
+    sdkVersion: 'ts-immutable-sdk-0.27.10',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8582,6 +8583,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";
@@ -8731,6 +8733,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 oidcClientTs.UserManager(getAuthConfiguration(config));
@@ -8975,32 +8981,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);
@@ -9027,14 +9053,16 @@ class MagicAdapter {
     magicClient;
     constructor(config) {
         this.config = config;
-        this.magicClient = new magicSdk.Magic(this.config.magicPublishableApiKey, {
-            extensions: [new oidc.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,
@@ -9043,10 +9071,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 magicSdk.Magic(this.config.magicPublishableApiKey, {
+            extensions: [new oidc.OpenIdExtension()],
+            network: this.config.network,
+        });
+    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -9133,16 +9167,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
@@ -9166,29 +9197,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');
             }
@@ -9232,7 +9264,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');
             }
@@ -9328,10 +9360,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,
@@ -9345,7 +9374,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;
@@ -9387,7 +9417,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;
@@ -9450,7 +9481,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;
@@ -9497,7 +9529,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;
@@ -9544,14 +9577,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) => {
@@ -9581,39 +9612,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,
         });
@@ -9628,52 +9660,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,
         });
     }
@@ -9696,9 +9728,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);
     }
 }
 
@@ -9752,9 +9784,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,
@@ -9763,7 +9795,7 @@ class PassportImxProviderFactory {
             });
         }
         return new PassportImxProvider({
-            user: user,
+            authManager: this.authManager,
             starkSigner,
             immutableXClient: this.immutableXClient,
             confirmationScreen: this.confirmationScreen,
@@ -10508,9 +10540,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]);
@@ -28000,10 +28030,8 @@ 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.ethers.utils.id('decimals()').substring(0, 10);
@@ -28036,7 +28064,7 @@ function isValidNonZeroAddress(address) {
 }
 const erc20ToUniswapToken = (token) => 
 // eslint-disable-next-line implicit-arrow-linebreak
-new sdkCore.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
+new Uniswap__namespace.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
 const uniswapTokenToERC20 = (token) => ({
     chainId: token.chainId,
     address: token.address,
@@ -28047,25 +28075,74 @@ const uniswapTokenToERC20 = (token) => ({
 });
 const toCurrencyAmount = (amount) => {
     const token = erc20ToUniswapToken(amount.token);
-    return sdkCore.CurrencyAmount.fromRawAmount(token, amount.value.toString());
+    return Uniswap__namespace.CurrencyAmount.fromRawAmount(token, amount.value.toString());
 };
 const newAmount = (amount, token) => ({
     value: amount,
     token,
 });
 const isERC20Amount = (amount) => amount.token.type === 'erc20';
+const isNativeAmount = (amount) => amount.token.type === 'native';
 const addERC20Amount = (a, b) => {
     // Make sure the ERC20s have the same address
     if (a.token.address !== b.token.address)
         throw new Error('Token mismatch: token addresses must be the same');
     return { value: a.value.add(b.value), token: a.token };
 };
+const addNativeAmount = (a, b) => ({
+    value: a.value.add(b.value),
+    token: a.token,
+});
+const addAmount = (a, b) => {
+    if (isERC20Amount(a) && isERC20Amount(b)) {
+        return addERC20Amount(a, b);
+    }
+    if (isNativeAmount(a) && isNativeAmount(b)) {
+        return addNativeAmount(a, b);
+    }
+    throw new Error('Token mismatch: token types must be the same');
+};
 const subtractERC20Amount = (a, b) => {
     // Make sure the ERC20s have the same address
     if (a.token.address !== b.token.address)
         throw new Error('Token mismatch: token addresses must be the same');
     return { value: a.value.sub(b.value), token: a.token };
 };
+const subtractNativeAmount = (a, b) => ({
+    value: a.value.sub(b.value),
+    token: a.token,
+});
+const subtractAmount = (a, b) => {
+    if (isERC20Amount(a) && isERC20Amount(b)) {
+        return subtractERC20Amount(a, b);
+    }
+    if (isNativeAmount(a) && isNativeAmount(b)) {
+        return subtractNativeAmount(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;
@@ -28107,8 +28184,8 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                 const output = uniswapTokenToERC20(routes[i].output);
                 decodedQuoteResults.push({
                     route: routes[i],
-                    amountIn: tradeType === sdkCore.TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
-                    amountOut: tradeType === sdkCore.TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
+                    amountIn: tradeType === Uniswap.TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
+                    amountOut: tradeType === Uniswap.TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
                     gasEstimate: ethers.ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
                     tradeType,
                 });
@@ -28281,11 +28358,11 @@ class Router {
             throw new NoRoutesAvailableError();
         }
         // We want to maximise the amountOut for the EXACT_INPUT type
-        if (tradeType === sdkCore.TradeType.EXACT_INPUT) {
+        if (tradeType === Uniswap.TradeType.EXACT_INPUT) {
             return this.bestQuoteForAmountIn(quotes);
         }
         // We want to minimise the amountIn for the EXACT_OUTPUT type
-        if (tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
+        if (tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
             return this.bestQuoteForAmountOut(quotes);
         }
         throw new Error('Invalid trade type');
@@ -28313,7 +28390,7 @@ class Router {
     // eslint-disable-next-line class-methods-use-this
     determineERC20InAndERC20Out(tradeType, amountSpecified, otherToken) {
         // If the trade type is EXACT INPUT then we have specified the amount for the tokenIn
-        return tradeType === sdkCore.TradeType.EXACT_INPUT
+        return tradeType === Uniswap.TradeType.EXACT_INPUT
             ? [amountSpecified.token, otherToken]
             : [otherToken, amountSpecified.token];
     }
@@ -28439,11 +28516,11 @@ const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAmount, spenderAd
         from: ownerAddress,
     };
 };
-const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, routingContracts, secondaryFees) => {
-    const amountOfTokenIn = tradeType === sdkCore.TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
+const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, contracts, secondaryFees) => {
+    const amountOfTokenIn = tradeType === Uniswap.TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
     const spender = secondaryFees.length === 0
-        ? routingContracts.peripheryRouterAddress
-        : routingContracts.secondaryFeeAddress;
+        ? contracts.routerAddress
+        : contracts.secondaryFeeAddress;
     return { spender, amount: amountOfTokenIn };
 };
 /**
@@ -28476,7 +28553,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;
@@ -28485,8 +28562,7 @@ 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,
     };
 };
 
@@ -28496,7 +28572,7 @@ const slippageToFraction = (slippage) => {
     // If we receive a whole number, we can return slippage/100
     const noDecimals = slippage.toString().split('.').length === 1;
     if (noDecimals) {
-        return new sdkCore.Percent(slippage, 100);
+        return new Uniswap.Percent(slippage, 100);
     }
     // Divide the slippage number by 100 to get the decimal
     const slippageDecimal = slippage / 100;
@@ -28506,11 +28582,11 @@ const slippageToFraction = (slippage) => {
     const numerator = parts[0] + parts[1];
     // Get the denominator by multiplying decimals^10
     const denominator = 10 ** parts[1].length;
-    return new sdkCore.Percent(numerator, denominator);
+    return new Uniswap.Percent(numerator, denominator);
 };
 
 function getQuoteAmountFromTradeType(tradeInfo) {
-    if (tradeInfo.tradeType === sdkCore.TradeType.EXACT_INPUT) {
+    if (tradeInfo.tradeType === Uniswap.TradeType.EXACT_INPUT) {
         return tradeInfo.amountOut;
     }
     return tradeInfo.amountIn;
@@ -28518,30 +28594,13 @@ function getQuoteAmountFromTradeType(tradeInfo) {
 function applySlippage(tradeType, amount, slippage) {
     const slippageTolerance = slippageToFraction(slippage);
     const slippagePlusOne = slippageTolerance.add(1);
-    const maybeInverted = tradeType === sdkCore.TradeType.EXACT_INPUT ? slippagePlusOne.invert() : slippagePlusOne;
+    const maybeInverted = tradeType === Uniswap.TradeType.EXACT_INPUT ? slippagePlusOne.invert() : slippagePlusOne;
     const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
     return ethers.ethers.BigNumber.from(amountWithSlippage.toString());
 }
-function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
-    const quote = getQuoteAmountFromTradeType(tradeInfo);
-    const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
-    return {
-        amount: quote,
-        amountWithMaxSlippage: {
-            token: otherToken,
-            value: amountWithSlippage,
-        },
-        slippage,
-        fees: fees.withAmounts(),
-    };
-}
 function getOurQuoteReqAmount(amountSpecified, // the amount specified by the user, either exactIn or exactOut
 fees, tradeType, nativeTokenService) {
-    // TODO: TP-1649: Remove this when we support Native
-    if (!isERC20Amount(amountSpecified)) {
-        throw new Error('Not implemented yet!');
-    }
-    if (tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
+    if (tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
         // For an exact output swap, we do not need to subtract fees from the given amount
         return nativeTokenService.maybeWrapAmount(amountSpecified);
     }
@@ -28571,14 +28630,17 @@ class Fees {
         this.secondaryFees = secondaryFees;
         this.amount = newAmount(ethers.BigNumber.from(0), token);
     }
+    get token() {
+        return this.amount.token;
+    }
     addAmount(amount) {
-        this.amount = addERC20Amount(this.amount, amount);
+        this.amount = addAmount(this.amount, amount);
     }
     amountWithFeesApplied() {
-        return addERC20Amount(this.amount, this.total());
+        return addAmount(this.amount, this.total());
     }
     amountLessFees() {
-        return subtractERC20Amount(this.amount, this.total());
+        return subtractAmount(this.amount, this.total());
     }
     withAmounts() {
         return this.secondaryFees.map((fee) => {
@@ -28597,7 +28659,7 @@ class Fees {
             const feeAmount = this.amount.value
                 .mul(fee.basisPoints)
                 .div(BASIS_POINT_PRECISION);
-            totalFees = addERC20Amount(totalFees, newAmount(feeAmount, this.amount.token));
+            totalFees = addAmount(totalFees, newAmount(feeAmount, this.amount.token));
         }
         return totalFees;
     }
@@ -28611,11 +28673,14 @@ class NativeTokenService {
         this.wrappedToken = wrappedToken;
     }
     wrapAmount(amount) {
+        if (!this.isNativeToken(amount.token)) {
+            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
+        }
         return newAmount(amount.value, this.wrappedToken);
     }
     unwrapAmount(amount) {
         if (amount.token !== this.wrappedToken) {
-            throw new Error(`token ${amount.token.address} is not wrapped`);
+            throw new Error(`cannot unwrap non-wrapped token ${amount.token.address}`);
         }
         return newAmount(amount.value, this.nativeToken);
     }
@@ -28635,14 +28700,6 @@ class NativeTokenService {
 
 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',
@@ -28671,7 +28728,7 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
         feeBasisPoints: fee.basisPoints,
         recipient: fee.recipient,
     }));
-    if (trade.tradeType === sdkCore.TradeType.EXACT_INPUT) {
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
         return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [secondaryFeeValues, {
                 tokenIn: route.tokenPath[0].address,
                 tokenOut: route.tokenPath[1].address,
@@ -28693,12 +28750,12 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
         }]);
 }
 function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
-    const path = v3Sdk.encodeRouteToPath(route, trade.tradeType === sdkCore.TradeType.EXACT_OUTPUT);
+    const path = v3Sdk.encodeRouteToPath(route, trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT);
     const secondaryFeeValues = secondaryFees.map((fee) => ({
         feeBasisPoints: fee.basisPoints,
         recipient: fee.recipient,
     }));
-    if (trade.tradeType === sdkCore.TradeType.EXACT_INPUT) {
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
         return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [secondaryFeeValues, {
                 path,
                 recipient: fromAddress,
@@ -28773,21 +28830,33 @@ function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouter
         gasFeeEstimate: gasFeeEstimate ? nativeTokenService.maybeWrapAmount(gasFeeEstimate) : null,
     };
 }
-function prepareSwap(ourQuote, amountSpecified, fees) {
-    if (ourQuote.tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
-        fees.addAmount(ourQuote.amountIn);
-        return {
-            gasEstimate: ourQuote.gasEstimate,
-            route: ourQuote.route,
-            amountIn: fees.amountWithFeesApplied(),
-            amountOut: amountSpecified,
-            tradeType: ourQuote.tradeType,
-        };
+const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
+    if (ourQuote.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
+        // when doing exact output, calculate the fees based on the amountIn
+        const amountToAdd = nativeTokenService.isNativeToken(fees.token)
+            ? nativeTokenService.unwrapAmount(ourQuote.amountIn)
+            : ourQuote.amountIn;
+        fees.addAmount(amountToAdd);
+        return nativeTokenService.maybeWrapAmount(fees.amountWithFeesApplied());
     }
+    return nativeTokenService.maybeWrapAmount(amountSpecified);
+};
+/**
+ * adjustQuoteWithFees adjusts the amountIn of the quote to account for fees
+ * EXACT_OUTPUT swaps will have the fees added to the amountIn if there are fees specified
+ * EXACT_INPUT swaps will have amountIn set to the user-specified amount
+ * @param ourQuote The quote from calling the Quoter contract
+ * @param amountSpecified The user-specified amount for the swap (EXACT...)
+ * @param fees The fees applied to the swap
+ * @param tokenWrapper Helper class for the native token and associated ERC20
+ * @returns {QuoteResult} The adjusted quote
+ */
+function adjustQuoteWithFees(ourQuote, amountSpecified, fees, nativeTokenService) {
+    const adjustedAmountIn = adjustAmountIn(ourQuote, amountSpecified, fees, nativeTokenService);
     return {
         gasEstimate: ourQuote.gasEstimate,
         route: ourQuote.route,
-        amountIn: amountSpecified,
+        amountIn: adjustedAmountIn,
         amountOut: ourQuote.amountOut,
         tradeType: ourQuote.tradeType,
     };
@@ -28808,7 +28877,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.
     },
 };
@@ -28880,6 +28949,15 @@ class ExchangeConfiguration {
     }
 }
 
+const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
+    amount,
+    amountWithMaxSlippage,
+    slippage,
+    fees: fees.withAmounts().map((fee) => ({
+        ...fee,
+        amount: toPublicAmount(fee.amount),
+    })),
+});
 class Exchange {
     provider;
     router;
@@ -28888,6 +28966,8 @@ class Exchange {
     wrappedNativeToken;
     secondaryFees;
     nativeTokenService;
+    secondaryFeeContractAddress;
+    routerContractAddress;
     constructor(configuration) {
         const config = new ExchangeConfiguration(configuration);
         this.chainId = config.chain.chainId;
@@ -28895,13 +28975,13 @@ class Exchange {
         this.wrappedNativeToken = config.chain.wrappedNativeToken;
         this.nativeTokenService = new NativeTokenService(this.nativeToken, this.wrappedNativeToken);
         this.secondaryFees = config.secondaryFees;
+        this.routerContractAddress = config.chain.contracts.peripheryRouter;
+        this.secondaryFeeContractAddress = config.chain.contracts.secondaryFee;
         this.provider = new ethers.ethers.providers.JsonRpcProvider(config.chain.rpcUrl);
         this.router = new Router(this.provider, config.chain.commonRoutingTokens, {
             multicallAddress: config.chain.contracts.multicall,
             factoryAddress: config.chain.contracts.coreFactory,
             quoterAddress: config.chain.contracts.quoterV2,
-            peripheryRouterAddress: config.chain.contracts.peripheryRouter,
-            secondaryFeeAddress: config.chain.contracts.secondaryFee,
         });
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
@@ -28918,7 +28998,7 @@ class Exchange {
         if (this.secondaryFees.length === 0) {
             return [];
         }
-        const secondaryFeeContract = SecondaryFee__factory.connect(this.router.routingContracts.secondaryFeeAddress, this.provider);
+        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, this.provider);
         if (await secondaryFeeContract.paused()) {
             // Do not use secondary fees if the contract is paused
             return [];
@@ -28946,8 +29026,7 @@ class Exchange {
             decimals: tokenOutDecimals,
         };
         // determine which amount was specified for the swap from the TradeType
-        const [tokenSpecified, otherToken] = tradeType === sdkCore.TradeType.EXACT_INPUT
-            ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+        const [tokenSpecified, otherToken] = tradeType === Uniswap.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);
@@ -28956,17 +29035,18 @@ class Exchange {
             this.router.findOptimalRoute(ourQuoteReqAmount, otherToken, tradeType, maxHops),
             fetchGasPrice(this.provider, this.nativeToken),
         ]);
-        const adjustedQuote = prepareSwap(ourQuote, amountSpecified, fees);
-        const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.router.routingContracts.peripheryRouterAddress, this.router.routingContracts.secondaryFeeAddress, gasPrice, secondaryFees, this.nativeTokenService);
-        const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees);
-        const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, this.router.routingContracts, secondaryFees);
+        const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
+        const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees, this.nativeTokenService);
+        const quotedAmount = getQuoteAmountFromTradeType(adjustedQuote);
+        const amountWithMaxSlippage = newAmount(applySlippage(adjustedQuote.tradeType, quotedAmount.value, slippagePercent), otherToken);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, amountWithMaxSlippage, {
+            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 = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice);
+        const quote = toPublicQuote(quotedAmount, amountWithMaxSlippage, slippagePercent, fees);
+        return { quote, approval, swap };
     }
     /**
      * Get the unsigned swap transaction given the amount to sell.
@@ -28982,7 +29062,7 @@ class Exchange {
      * @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.ethers.BigNumber.from(amountIn), slippagePercent, maxHops, deadline, sdkCore.TradeType.EXACT_INPUT);
+        return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.ethers.BigNumber.from(amountIn), slippagePercent, maxHops, deadline, Uniswap.TradeType.EXACT_INPUT);
     }
     /**
      * Get the unsigned swap transaction given the amount to buy.
@@ -28998,7 +29078,7 @@ class Exchange {
      * @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.ethers.BigNumber.from(amountOut), slippagePercent, maxHops, deadline, sdkCore.TradeType.EXACT_OUTPUT);
+        return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.ethers.BigNumber.from(amountOut), slippagePercent, maxHops, deadline, Uniswap.TradeType.EXACT_OUTPUT);
     }
 }
 
@@ -33158,7 +33238,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.8";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.10";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;