@imtbl/sdk 0.33.0 → 0.34.0

package/dist/index.cjs

@@ -3791,7 +3791,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.33.0' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.34.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3851,7 +3851,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.33.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.34.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4262,7 +4262,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.33.0',
+    sdkVersion: 'ts-immutable-sdk-0.34.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8812,26 +8812,10 @@ var ChainName$1;
     ChainName["IMTBL_ZKEVM_MAINNET"] = "Immutable zkEVM";
 })(ChainName$1 || (ChainName$1 = {}));
 
-const keyCrendentials = 'passport_credentials';
 const KEY_PKCE_STATE = 'pkce_state';
 const KEY_PKCE_VERIFIER = 'pkce_verifier';
 const validCredentialsMinTtlSec = 3600; // 1 hour
 class DeviceCredentialsManager {
-    saveCredentials(tokenResponse) {
-        if (this.areValid(tokenResponse)) {
-            localStorage.setItem(keyCrendentials, JSON.stringify(tokenResponse));
-        }
-        else {
-            throw Error('Invalid credentials.');
-        }
-    }
-    getCredentials() {
-        const credentialsJson = localStorage.getItem(keyCrendentials);
-        if (credentialsJson) {
-            return JSON.parse(credentialsJson);
-        }
-        return null;
-    }
     areValid(tokenResponse) {
         if (tokenResponse) {
             const accessTokenValid = this.isTokenValid(tokenResponse.access_token);
@@ -8851,9 +8835,6 @@ class DeviceCredentialsManager {
             return false;
         }
     }
-    clearCredentials() {
-        localStorage.removeItem(keyCrendentials);
-    }
     savePKCEData(data) {
         localStorage.setItem(KEY_PKCE_STATE, data.state);
         localStorage.setItem(KEY_PKCE_VERIFIER, data.verifier);
@@ -8889,9 +8870,14 @@ const formUrlEncodedHeader = {
         'Content-Type': 'application/x-www-form-urlencoded',
     },
 };
-const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
+const getAuthConfiguration = (config) => {
+    const { authenticationDomain, oidcConfiguration } = config;
     const store = typeof window !== 'undefined' ? window.localStorage : new oidcClientTs.InMemoryWebStorage();
     const userStore = new oidcClientTs.WebStorageStateStore({ store });
+    let endSessionEndpoint = `${authenticationDomain}/v2/logout?client_id=${oidcConfiguration.clientId}`;
+    if (oidcConfiguration.logoutRedirectUri) {
+        endSessionEndpoint += `&returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`;
+    }
     const baseConfiguration = {
         authority: authenticationDomain,
         redirect_uri: oidcConfiguration.redirectUri,
@@ -8901,9 +8887,7 @@ const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
             authorization_endpoint: `${authenticationDomain}/authorize`,
             token_endpoint: `${authenticationDomain}/oauth/token`,
             userinfo_endpoint: `${authenticationDomain}/userinfo`,
-            end_session_endpoint: `${authenticationDomain}/v2/logout`
-                + `?returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`
-                + `&client_id=${oidcConfiguration.clientId}`,
+            end_session_endpoint: endSessionEndpoint,
         },
         mergeClaims: true,
         loadUserInfo: true,
@@ -8922,6 +8906,15 @@ function wait$1(ms) {
         setTimeout(resolve, ms);
     });
 }
+function base64URLEncode(str) {
+    return str.toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+function sha256(buffer) {
+    return crypto__namespace.createHash('sha256').update(buffer).digest();
+}
 class AuthManager {
     userManager;
     config;
@@ -8965,32 +8958,24 @@ class AuthManager {
         }
         return user;
     };
-    static mapDeviceTokenResponseToDomainUserModel = (tokenResponse) => {
+    static mapDeviceTokenResponseToOidcUser = (tokenResponse) => {
         const idTokenPayload = jwt_decode(tokenResponse.id_token);
-        const user = {
-            idToken: tokenResponse.id_token,
-            accessToken: tokenResponse.access_token,
-            refreshToken: tokenResponse.refresh_token,
+        return new oidcClientTs.User({
+            id_token: tokenResponse.id_token,
+            access_token: tokenResponse.access_token,
+            refresh_token: tokenResponse.refresh_token,
+            token_type: tokenResponse.token_type,
             profile: {
                 sub: idTokenPayload.sub,
+                iss: idTokenPayload.iss,
+                aud: idTokenPayload.aud,
+                exp: idTokenPayload.exp,
+                iat: idTokenPayload.iat,
                 email: idTokenPayload.email,
                 nickname: idTokenPayload.nickname,
+                passport: idTokenPayload.passport,
             },
-        };
-        if (idTokenPayload?.passport?.imx_eth_address) {
-            user.imx = {
-                ethAddress: idTokenPayload.passport.imx_eth_address,
-                starkAddress: idTokenPayload.passport.imx_stark_address,
-                userAdminAddress: idTokenPayload.passport.imx_user_admin_address,
-            };
-        }
-        if (idTokenPayload?.passport?.zkevm_eth_address) {
-            user.zkEvm = {
-                ethAddress: idTokenPayload?.passport?.zkevm_eth_address,
-                userAdminAddress: idTokenPayload?.passport?.zkevm_user_admin_address,
-            };
-        }
-        return user;
+        });
     };
     async login() {
         return withPassportError(async () => {
@@ -9020,7 +9005,7 @@ class AuthManager {
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
     /* eslint-disable no-await-in-loop */
-    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
         return withPassportError(async () => {
             const startTime = Date.now();
             const loopCondition = true;
@@ -9031,8 +9016,9 @@ class AuthManager {
                 await wait$1(interval * 1000);
                 try {
                     const tokenResponse = await this.getDeviceFlowToken(deviceCode);
-                    const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-                    this.deviceCredentialsManager.saveCredentials(tokenResponse);
+                    const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+                    const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+                    await this.userManager.storeUser(oidcUser);
                     return user;
                 }
                 catch (error) {
@@ -9068,20 +9054,11 @@ class AuthManager {
         }, formUrlEncodedHeader);
         return response.data;
     }
-    static base64URLEncode(str) {
-        return str.toString('base64')
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=/g, '');
-    }
-    static sha256(buffer) {
-        return crypto__namespace.createHash('sha256').update(buffer).digest();
-    }
     getPKCEAuthorizationUrl() {
-        const verifier = AuthManager.base64URLEncode(crypto__namespace.randomBytes(32));
-        const challenge = AuthManager.base64URLEncode(AuthManager.sha256(verifier));
+        const verifier = base64URLEncode(crypto__namespace.randomBytes(32));
+        const challenge = base64URLEncode(sha256(verifier));
         // https://auth0.com/docs/secure/attack-protection/state-parameters
-        const state = AuthManager.base64URLEncode(crypto__namespace.randomBytes(32));
+        const state = base64URLEncode(crypto__namespace.randomBytes(32));
         this.deviceCredentialsManager.savePKCEData({ state, verifier });
         return `${this.config.authenticationDomain}/authorize?`
             + 'response_type=code'
@@ -9103,8 +9080,9 @@ class AuthManager {
                 throw new Error('Provided state does not match stored state');
             }
             const tokenResponse = await this.getPKCEToken(authorizationCode, pkceData.verifier);
-            const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-            this.deviceCredentialsManager.saveCredentials(tokenResponse);
+            const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+            const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+            await this.userManager.storeUser(oidcUser);
             return user;
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
@@ -9118,31 +9096,6 @@ class AuthManager {
         }, formUrlEncodedHeader);
         return response.data;
     }
-    async connectImxWithCredentials(tokenResponse) {
-        return withPassportError(async () => {
-            if (this.deviceCredentialsManager.areValid(tokenResponse)) {
-                // Credentials exist and are still valid
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-            }
-            const refreshToken = tokenResponse?.refresh_token ?? null;
-            if (refreshToken) {
-                // Token is no longer valid, but refresh token can be used to a new one
-                const user = await this.refreshToken(refreshToken);
-                return user;
-            }
-            return null;
-        }, PassportErrorType.AUTHENTICATION_ERROR);
-    }
-    async refreshToken(refreshToken) {
-        const response = await globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
-            client_id: this.config.oidcConfiguration.clientId,
-            grant_type: 'refresh_token',
-            refresh_token: refreshToken,
-        }, formUrlEncodedHeader);
-        const newTokenResponse = response.data;
-        this.deviceCredentialsManager.saveCredentials(newTokenResponse);
-        return AuthManager.mapDeviceTokenResponseToDomainUserModel(newTokenResponse);
-    }
     async logout() {
         return withPassportError(async () => {
             if (this.logoutMode === 'silent') {
@@ -9151,29 +9104,20 @@ class AuthManager {
             return this.userManager.signoutRedirect();
         }, PassportErrorType.LOGOUT_ERROR);
     }
-    async logoutSilentCallback(url) {
-        return this.userManager.signoutSilentCallback(url);
-    }
-    async logoutDeviceFlow() {
-        return withPassportError(async () => {
-            this.deviceCredentialsManager.clearCredentials();
-        }, PassportErrorType.LOGOUT_ERROR);
+    async removeUser() {
+        return this.userManager.removeUser();
     }
-    /**
-     * Get the user from the cache or refresh the token if it's expired.
-     * return null if there's no refresh token.
-     */
-    async getAuthenticatedUser() {
-        const oidcUser = await this.userManager.getUser();
-        if (!oidcUser)
-            return null;
-        if (!isTokenExpired(oidcUser)) {
-            return AuthManager.mapOidcUserToDomainModel(oidcUser);
+    getDeviceFlowEndSessionEndpoint() {
+        const { authenticationDomain, oidcConfiguration } = this.config;
+        let endSessionEndpoint = `${authenticationDomain}/v2/logout`;
+        if (oidcConfiguration.logoutRedirectUri) {
+            endSessionEndpoint += `?client_id=${oidcConfiguration.clientId}`
+                + `&returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`;
         }
-        if (oidcUser.refresh_token) {
-            return this.refreshTokenAndUpdatePromise();
-        }
-        return null;
+        return endSessionEndpoint;
+    }
+    async logoutSilentCallback(url) {
+        return this.userManager.signoutSilentCallback(url);
     }
     async forceUserRefresh() {
         return this.refreshTokenAndUpdatePromise();
@@ -9188,25 +9132,10 @@ class AuthManager {
         // eslint-disable-next-line no-async-promise-executor
         this.refreshingPromise = new Promise(async (resolve, reject) => {
             try {
-                if (this.config.crossSdkBridgeEnabled) {
-                    const tokenResponse = this.checkStoredDeviceFlowCredentials();
-                    if (tokenResponse) {
-                        const refreshToken = tokenResponse?.refresh_token ?? null;
-                        if (refreshToken) {
-                            const newUser = await this.refreshToken(refreshToken);
-                            if (newUser) {
-                                resolve(newUser);
-                                return;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const newOidcUser = await this.userManager.signinSilent();
-                    if (newOidcUser) {
-                        resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
-                        return;
-                    }
+                const newOidcUser = await this.userManager.signinSilent();
+                if (newOidcUser) {
+                    resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
+                    return;
                 }
                 resolve(null);
             }
@@ -9219,30 +9148,24 @@ class AuthManager {
         });
         return this.refreshingPromise;
     }
+    /**
+     * Get the user from the cache or refresh the token if it's expired.
+     * return null if there's no refresh token.
+     */
     async getUser() {
         return withPassportError(async () => {
-            const user = await this.getAuthenticatedUser();
-            if (user)
-                return user;
-            const deviceToken = this.deviceCredentialsManager.getCredentials();
-            if (deviceToken) {
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            const oidcUser = await this.userManager.getUser();
+            if (!oidcUser)
+                return null;
+            if (!isTokenExpired(oidcUser)) {
+                return AuthManager.mapOidcUserToDomainModel(oidcUser);
             }
-            return null;
-        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
-    }
-    async getUserDeviceFlow() {
-        return withPassportError(async () => {
-            const deviceToken = this.deviceCredentialsManager.getCredentials();
-            if (deviceToken) {
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            if (oidcUser.refresh_token) {
+                return this.refreshTokenAndUpdatePromise();
             }
             return null;
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
     }
-    checkStoredDeviceFlowCredentials() {
-        return this.deviceCredentialsManager.getCredentials();
-    }
 }
 
 const lazyLoad = (promiseToAwait, initialiseFunction) => promiseToAwait().then(initialiseFunction);
@@ -10077,21 +10000,10 @@ class PassportImxProviderFactory {
         }
         return this.createProviderInstance(user);
     }
-    async getProviderWithDeviceFlow(deviceCode, interval, timeoutMs) {
-        const user = await this.authManager.connectImxDeviceFlow(deviceCode, interval, timeoutMs);
-        return this.createProviderInstance(user);
-    }
     async getProviderWithPKCEFlow(authorizationCode, state) {
         const user = await this.authManager.connectImxPKCEFlow(authorizationCode, state);
         return this.createProviderInstance(user);
     }
-    async getProviderWithCredentials(tokenResponse) {
-        const user = await this.authManager.connectImxWithCredentials(tokenResponse);
-        if (!user) {
-            return null;
-        }
-        return this.createProviderInstance(user);
-    }
     async createProviderInstance(user) {
         if (!user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
@@ -10135,7 +10047,6 @@ class PassportConfiguration {
     constructor({ baseConfig, overrides, crossSdkBridgeEnabled, ...oidcConfiguration }) {
         validateConfiguration(oidcConfiguration, [
             'clientId',
-            'logoutRedirectUri',
             'redirectUri',
         ]);
         this.oidcConfiguration = oidcConfiguration;
@@ -10610,7 +10521,7 @@ const CHAIN_NAME_MAP = new Map([
 ]);
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function registerZkEvmUser({ authManager, config, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
+async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
     const web3Provider = new providers.Web3Provider(magicProvider);
     const ethSigner = web3Provider.getSigner();
     const ethereumAddress = await ethSigner.getAddress();
@@ -10633,24 +10544,14 @@ async function registerZkEvmUser({ authManager, config, magicProvider, multiRoll
     catch (error) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
     }
-    let user;
-    if (config.crossSdkBridgeEnabled) {
-        const credentials = authManager.checkStoredDeviceFlowCredentials();
-        if (!credentials || !credentials.refresh_token) {
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Cross SDK bridge: Failed to refresh user details');
-        }
-        user = await authManager.refreshToken(credentials.refresh_token);
-    }
-    else {
-        user = await authManager.forceUserRefresh();
-    }
+    const user = await authManager.forceUserRefresh();
     if (!user?.zkEvm) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
     }
     return user;
 }
 
-const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
+const loginZkEvmUser = async ({ authManager, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
     let user = null;
     try {
         user = await authManager.getUser();
@@ -10660,7 +10561,7 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
         console.warn('eth_requestAccounts` failed to retrieve a cached user session:', err);
     }
     if (!user) {
-        user = await authManager.getUserDeviceFlow() || await authManager.login();
+        user = await authManager.login();
     }
     if (!user.idToken) {
         throw new Error('User is missing idToken');
@@ -10670,7 +10571,6 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
         // Generate counterfactual address and retrieve updated Auth0 user
         const userZkevm = await registerZkEvmUser({
             authManager,
-            config,
             magicProvider,
             multiRollupApiClients,
             accessToken: user.accessToken,
@@ -11094,24 +10994,12 @@ class Passport {
     async connectImx() {
         return this.passportImxProviderFactory.getProvider();
     }
-    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
-        return this.passportImxProviderFactory.getProviderWithDeviceFlow(deviceCode, interval, timeoutMs);
-    }
     getPKCEAuthorizationUrl() {
         return this.authManager.getPKCEAuthorizationUrl();
     }
     async connectImxPKCEFlow(authorizationCode, state) {
         return this.passportImxProviderFactory.getProviderWithPKCEFlow(authorizationCode, state);
     }
-    /**
-     * @returns {boolean} the stored device flow credentials if they exist
-     */
-    checkStoredDeviceFlowCredentials() {
-        return this.authManager.checkStoredDeviceFlowCredentials();
-    }
-    async connectImxWithCredentials(tokenResponse) {
-        return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
-    }
     connectEvm() {
         if (this.config.network === Networks.PRODUCTION) {
             throw new Error('EVM is not supported on production network');
@@ -11151,19 +11039,35 @@ class Passport {
         }
         return user ? user.profile : null;
     }
+    async loginCallback() {
+        return this.authManager.loginCallback();
+    }
     async loginWithDeviceFlow() {
         return this.authManager.loginWithDeviceFlow();
     }
-    async loginCallback() {
-        return this.authManager.loginCallback();
+    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
+        const user = await this.authManager.loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs);
+        return user.profile;
     }
     async logout() {
-        await this.authManager.logout();
         await this.confirmationScreen.logout();
+        await this.authManager.logout();
         // Code after this point is only executed if the logout mode is silent
         await this.magicAdapter.logout();
         this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
     }
+    /**
+     * Logs the user out of Passport when using device flow authentication.
+     *
+     * @returns {Promise<string>} The device flow end session endpoint. Consumers are responsible for
+     * opening this URL in the same browser that was used to log the user in.
+     */
+    async logoutDeviceFlow() {
+        await this.authManager.removeUser();
+        await this.magicAdapter.logout();
+        this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
+        return this.authManager.getDeviceFlowEndSessionEndpoint();
+    }
     /**
      * This method should only be called from the logout redirect uri
      * when logout mode is 'silent'.
@@ -11171,17 +11075,10 @@ class Passport {
     async logoutSilentCallback(url) {
         return this.authManager.logoutSilentCallback(url);
     }
-    async logoutDeviceFlow() {
-        return this.authManager.logoutDeviceFlow();
-    }
     async getUserInfo() {
         const user = await this.authManager.getUser();
         return user?.profile;
     }
-    async getUserInfoDeviceFlow() {
-        const user = await this.authManager.getUserDeviceFlow();
-        return user?.profile;
-    }
     async getIdToken() {
         const user = await this.authManager.getUser();
         return user?.idToken;
@@ -11635,7 +11532,7 @@ class OrdersService {
      * @returns ListListingsResult OK response.
      * @throws ApiError
      */
-    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/v1/chains/{chain_name}/orders/listings',
@@ -11646,6 +11543,8 @@ class OrdersService {
                 'status': status,
                 'sell_item_contract_address': sellItemContractAddress,
                 'buy_item_contract_address': buyItemContractAddress,
+                'account_address': accountAddress,
+                'sell_item_metadata_id': sellItemMetadataId,
                 'sell_item_token_id': sellItemTokenId,
                 'from_updated_at': fromUpdatedAt,
                 'page_size': pageSize,
@@ -28572,6 +28471,21 @@ const getCallData = (methodName, contractInterface) => {
     return fragment ? contractInterface?.encodeFunctionData(fragment) : undefined;
 };
 
+// 0.1% default slippage
+const DEFAULT_SLIPPAGE = 0.1;
+// 15 minutes from the time the transaction was prepared
+const DEFAULT_DEADLINE_SECONDS = 60 * 15;
+// most swaps will be able to resolve with 2 hops
+const DEFAULT_MAX_HOPS = 2;
+// after 10 hops, it is very unlikely a route will be available
+const MAX_MAX_HOPS = 10;
+// a max hop of 1 will require a direct swap with no intermediary pools
+const MIN_MAX_HOPS = 1;
+// precision used to calculate percentage from basis points
+const BASIS_POINT_PRECISION = 10000;
+// 10% maximum secondary fee
+const MAX_SECONDARY_FEE_BASIS_POINTS = 1000;
+
 const quoteReturnMapping = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     '0xcdca1753': ['uint256', 'uint160[]', 'uint32[]', 'uint256'],
@@ -28706,6 +28620,7 @@ const toPublicAmount = (amount) => ({
     token: toPublicTokenType(amount.token),
     value: amount.value,
 });
+const getDefaultDeadlineSeconds = () => Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE_SECONDS;
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
@@ -29204,21 +29119,6 @@ fees, tradeType, nativeTokenService) {
     return nativeTokenService.maybeWrapAmount(fees.amountLessFees());
 }
 
-// 0.1% default slippage
-const DEFAULT_SLIPPAGE = 0.1;
-// 15 minutes from the current Unix time
-const DEFAULT_DEADLINE = Math.floor(Date.now() / 1000) + 60 * 15;
-// most swaps will be able to resolve with 2 hops
-const DEFAULT_MAX_HOPS = 2;
-// after 10 hops, it is very unlikely a route will be available
-const MAX_MAX_HOPS = 10;
-// a max hop of 1 will require a direct swap with no intermediary pools
-const MIN_MAX_HOPS = 1;
-// precision used to calculate percentage from basis points
-const BASIS_POINT_PRECISION = 10000;
-// 10% maximum secondary fee
-const MAX_SECONDARY_FEE_BASIS_POINTS = 1000;
-
 class Fees {
     secondaryFees;
     amount;
@@ -29763,7 +29663,7 @@ class Exchange {
      * @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) {
+    async getUnsignedSwapTxFromAmountIn(fromAddress, tokenInAddress, tokenOutAddress, amountIn, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = getDefaultDeadlineSeconds()) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.ethers.BigNumber.from(amountIn), slippagePercent, maxHops, deadline, Uniswap.TradeType.EXACT_INPUT);
     }
     /**
@@ -29779,7 +29679,7 @@ class Exchange {
      * @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) {
+    async getUnsignedSwapTxFromAmountOut(fromAddress, tokenInAddress, tokenOutAddress, amountOut, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = getDefaultDeadlineSeconds()) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.ethers.BigNumber.from(amountOut), slippagePercent, maxHops, deadline, Uniswap.TradeType.EXACT_OUTPUT);
     }
 }
@@ -30672,7 +30572,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.33.0';
+const SDK_VERSION_MARKER = '0.34.0';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -31031,8 +30931,8 @@ const resetBlockscoutClientMap = () => blockscoutClientMap.clear();
 const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
-    const shouldFilter = filterTokens.length > 0;
-    const mapFilterTokens = Object.assign({}, ...(filterTokens.map((t) => ({ [t.address || NATIVE]: t }))));
+    const shouldFilter = filterTokens !== undefined;
+    const mapFilterTokens = Object.assign({}, ...((filterTokens ?? []).map((t) => ({ [t.address || NATIVE]: t }))));
     // Get blockscout client for the given chain
     let blockscoutClient = blockscoutClientMap.get(chainId);
     if (!blockscoutClient) {
@@ -31152,7 +31052,7 @@ const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
         // Please remove this hack once https://immutable.atlassian.net/browse/WT-1710
         // is done.
         const isL1Chain = getL1ChainId(config) === chainId;
-        return await measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(walletAddress, chainId, isL1Chain ? tokens : []));
+        return await measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(walletAddress, chainId, isL1Chain ? tokens : undefined));
     }
     // This fallback to use ERC20s calls which is a best effort solution
     // Fails in fetching data from the RCP calls might result in some