@imtbl/sdk 1.13.5 → 1.13.6-alpha

package/dist/passport.js

@@ -2,7 +2,7 @@ import globalAxios$1, { isAxiosError as isAxiosError$1 } from 'axios';
 import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { memorise } from 'lru-memorise';
 import { getGlobalisedValue as getGlobalisedValue$1 } from 'global-const';
-import { UserManager, User, ErrorTimeout, ErrorResponse, InMemoryWebStorage, WebStorageStateStore } from 'oidc-client-ts';
+import { UserManager, ErrorTimeout, ErrorResponse, User, InMemoryWebStorage, WebStorageStateStore } from 'oidc-client-ts';
 import jwt_decode from 'jwt-decode';
 import * as crypto from 'crypto';
 import { Magic } from 'magic-sdk';
@@ -8399,7 +8399,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.13.5' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.13.6-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -8578,7 +8578,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.13.5';
+const SDK_VERSION = '1.13.6-alpha';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -8797,7 +8797,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.13.5',
+    sdkVersion: 'ts-immutable-sdk-1.13.6-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -13278,6 +13278,63 @@ const TransactionApprovalRequestChainTypeEnum = {
     Evm: 'evm'
 };
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -13300,19 +13357,19 @@ function isAPIError(error) {
     return 'code' in error && 'message' in error;
 }
 class PassportError extends Error {
-    type;
     constructor(message, type) {
         super(message);
         this.type = type;
     }
 }
-const withPassportError = async (fn, customErrorType) => {
+const withPassportError = (fn, customErrorType) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
     try {
-        return await fn();
+        return yield fn();
     }
     catch (error) {
         let errorMessage;
-        if (isAxiosError$1(error) && error.response?.data && isAPIError(error.response.data)) {
+        if (isAxiosError$1(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) && isAPIError(error.response.data)) {
             errorMessage = error.response.data.message;
         }
         else {
@@ -13320,7 +13377,7 @@ const withPassportError = async (fn, customErrorType) => {
         }
         throw new PassportError(errorMessage, customErrorType);
     }
-};
+});
 
 /**
  * Enum representing different chain IDs.
@@ -13370,9 +13427,10 @@ class DeviceCredentialsManager {
         return false;
     }
     isTokenValid(jwt) {
+        var _a;
         try {
             const tokenPayload = jwt_decode(jwt);
-            const expiresAt = tokenPayload.exp ?? 0;
+            const expiresAt = (_a = tokenPayload.exp) !== null && _a !== void 0 ? _a : 0;
             const now = (Date.now() / 1000) + validCredentialsMinTtlSec;
             return expiresAt > now;
         }
@@ -13394,7 +13452,8 @@ class DeviceCredentialsManager {
     }
 }
 
-const shouldLog = process?.env?.JEST_WORKER_ID === undefined;
+var _a;
+const shouldLog = ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.JEST_WORKER_ID) === undefined;
 const warn = (...args) => {
     if (shouldLog) {
         // eslint-disable-next-line no-console
@@ -13478,171 +13537,127 @@ function sha256(buffer) {
     return crypto.createHash('sha256').update(buffer).digest();
 }
 class AuthManager {
-    userManager;
-    deviceCredentialsManager;
-    config;
-    logoutMode;
-    /**
-     * Promise that is used to prevent multiple concurrent calls to the refresh token endpoint.
-     */
-    refreshingPromise = null;
     constructor(config) {
+        /**
+         * Promise that is used to prevent multiple concurrent calls to the refresh token endpoint.
+         */
+        this.refreshingPromise = null;
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
         this.deviceCredentialsManager = new DeviceCredentialsManager();
         this.logoutMode = config.oidcConfiguration.logoutMode || 'redirect';
     }
-    static mapOidcUserToDomainModel = (oidcUser) => {
-        let passport;
-        if (oidcUser.id_token) {
-            passport = jwt_decode(oidcUser.id_token)?.passport;
-        }
-        const user = {
-            expired: oidcUser.expired,
-            idToken: oidcUser.id_token,
-            accessToken: oidcUser.access_token,
-            refreshToken: oidcUser.refresh_token,
-            profile: {
-                sub: oidcUser.profile.sub,
-                email: oidcUser.profile.email,
-                nickname: oidcUser.profile.nickname,
-            },
-        };
-        if (passport?.imx_eth_address) {
-            user.imx = {
-                ethAddress: passport.imx_eth_address,
-                starkAddress: passport.imx_stark_address,
-                userAdminAddress: passport.imx_user_admin_address,
-            };
-        }
-        if (passport?.zkevm_eth_address) {
-            user.zkEvm = {
-                ethAddress: passport?.zkevm_eth_address,
-                userAdminAddress: passport?.zkevm_user_admin_address,
-            };
-        }
-        return user;
-    };
-    static mapDeviceTokenResponseToOidcUser = (tokenResponse) => {
-        const idTokenPayload = jwt_decode(tokenResponse.id_token);
-        return new 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,
-            },
-        });
-    };
     /**
      * login
      * @param anonymousId Caller can pass an anonymousId if they want to associate their user's identity with immutable's internal instrumentation.
      */
-    async login(anonymousId) {
-        return withPassportError(async () => {
-            const rid = getDetail(Detail.RUNTIME_ID);
-            const popupWindowFeatures = { width: 410, height: 450 };
-            const oidcUser = await this.userManager.signinPopup({
-                extraQueryParams: {
-                    ...(this.userManager.settings?.extraQueryParams ?? {}),
-                    rid: rid || '',
-                    third_party_a_id: anonymousId || '',
-                },
-                popupWindowFeatures,
-            });
-            return AuthManager.mapOidcUserToDomainModel(oidcUser);
-        }, PassportErrorType.AUTHENTICATION_ERROR);
+    login(anonymousId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const rid = getDetail(Detail.RUNTIME_ID);
+                const popupWindowFeatures = { width: 410, height: 450 };
+                const oidcUser = yield this.userManager.signinPopup({
+                    extraQueryParams: Object.assign(Object.assign({}, ((_b = (_a = this.userManager.settings) === null || _a === void 0 ? void 0 : _a.extraQueryParams) !== null && _b !== void 0 ? _b : {})), { rid: rid || '', third_party_a_id: anonymousId || '' }),
+                    popupWindowFeatures,
+                });
+                return AuthManager.mapOidcUserToDomainModel(oidcUser);
+            }), PassportErrorType.AUTHENTICATION_ERROR);
+        });
     }
-    async getUserOrLogin() {
-        let user = null;
-        try {
-            user = await this.getUser();
-        }
-        catch (err) {
-            logger.warn('Failed to retrieve a cached user session', err);
-        }
-        return user || this.login();
+    getUserOrLogin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = null;
+            try {
+                user = yield this.getUser();
+            }
+            catch (err) {
+                logger.warn('Failed to retrieve a cached user session', err);
+            }
+            return user || this.login();
+        });
     }
-    async loginCallback() {
-        return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
+    loginCallback() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () { return this.userManager.signinPopupCallback(); }), PassportErrorType.AUTHENTICATION_ERROR);
+        });
     }
     /**
      * loginWithDeviceFlow
      * @param anonymousId Caller can pass an anonymousId if they want to associate their user's identity with immutable's internal instrumentation.
      */
-    async loginWithDeviceFlow(anonymousId) {
-        return withPassportError(async () => {
-            const response = await globalAxios$1.post(`${this.config.authenticationDomain}/oauth/device/code`, {
-                client_id: this.config.oidcConfiguration.clientId,
-                scope: this.config.oidcConfiguration.scope,
-                audience: this.config.oidcConfiguration.audience,
-            }, formUrlEncodedHeader);
-            const rid = getDetail(Detail.RUNTIME_ID);
-            return {
-                code: response.data.user_code,
-                deviceCode: response.data.device_code,
-                url: `${response.data.verification_uri_complete}${rid ? `&rid=${rid}` : ''}${anonymousId ? `&third_party_a_id=${anonymousId}` : ''}`,
-                interval: response.data.interval,
-            };
-        }, PassportErrorType.AUTHENTICATION_ERROR);
+    loginWithDeviceFlow(anonymousId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                const response = yield globalAxios$1.post(`${this.config.authenticationDomain}/oauth/device/code`, {
+                    client_id: this.config.oidcConfiguration.clientId,
+                    scope: this.config.oidcConfiguration.scope,
+                    audience: this.config.oidcConfiguration.audience,
+                }, formUrlEncodedHeader);
+                const rid = getDetail(Detail.RUNTIME_ID);
+                return {
+                    code: response.data.user_code,
+                    deviceCode: response.data.device_code,
+                    url: `${response.data.verification_uri_complete}${rid ? `&rid=${rid}` : ''}${anonymousId ? `&third_party_a_id=${anonymousId}` : ''}`,
+                    interval: response.data.interval,
+                };
+            }), PassportErrorType.AUTHENTICATION_ERROR);
+        });
     }
     /* eslint-disable no-await-in-loop */
-    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
-        return withPassportError(async () => {
-            const startTime = Date.now();
-            const loopCondition = true;
-            while (loopCondition) {
-                if (timeoutMs != null && Date.now() - startTime > timeoutMs) {
-                    throw new Error('Timed out');
-                }
-                await wait$1(interval * 1000);
-                try {
-                    const tokenResponse = await this.getDeviceFlowToken(deviceCode);
-                    const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
-                    const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
-                    await this.userManager.storeUser(oidcUser);
-                    return user;
-                }
-                catch (error) {
-                    if (globalAxios$1.isAxiosError(error)) {
-                        const responseError = error.response?.data;
-                        switch (responseError.error) {
-                            case 'authorization_pending':
-                                break;
-                            case 'slow_down':
-                                break;
-                            case 'expired_token':
-                                throw new Error('Token expired, please log in again');
-                            case 'access_denied':
-                                throw new Error('User denied access');
-                            default:
-                                throw new Error('Error getting token');
-                        }
+    loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const startTime = Date.now();
+                const loopCondition = true;
+                while (loopCondition) {
+                    if (timeoutMs != null && Date.now() - startTime > timeoutMs) {
+                        throw new Error('Timed out');
+                    }
+                    yield wait$1(interval * 1000);
+                    try {
+                        const tokenResponse = yield this.getDeviceFlowToken(deviceCode);
+                        const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+                        const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+                        yield this.userManager.storeUser(oidcUser);
+                        return user;
                     }
-                    else {
-                        throw error;
+                    catch (error) {
+                        if (globalAxios$1.isAxiosError(error)) {
+                            const responseError = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data;
+                            switch (responseError.error) {
+                                case 'authorization_pending':
+                                    break;
+                                case 'slow_down':
+                                    break;
+                                case 'expired_token':
+                                    throw new Error('Token expired, please log in again');
+                                case 'access_denied':
+                                    throw new Error('User denied access');
+                                default:
+                                    throw new Error('Error getting token');
+                            }
+                        }
+                        else {
+                            throw error;
+                        }
                     }
                 }
-            }
-            throw new Error('Failed to get credentials');
-        }, PassportErrorType.AUTHENTICATION_ERROR);
+                throw new Error('Failed to get credentials');
+            }), PassportErrorType.AUTHENTICATION_ERROR);
+        });
     }
     /* eslint-enable no-await-in-loop */
-    async getDeviceFlowToken(deviceCode) {
-        const response = await globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
-            client_id: this.config.oidcConfiguration.clientId,
-            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
-            device_code: deviceCode,
-        }, formUrlEncodedHeader);
-        return response.data;
+    getDeviceFlowToken(deviceCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
+                client_id: this.config.oidcConfiguration.clientId,
+                grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                device_code: deviceCode,
+            }, formUrlEncodedHeader);
+            return response.data;
+        });
     }
     getPKCEAuthorizationUrl() {
         const verifier = base64URLEncode(crypto.randomBytes(32));
@@ -13660,42 +13675,50 @@ class AuthManager {
             + `&state=${state}`
             + `&audience=${this.config.oidcConfiguration.audience}`;
     }
-    async loginWithPKCEFlowCallback(authorizationCode, state) {
-        return withPassportError(async () => {
-            const pkceData = this.deviceCredentialsManager.getPKCEData();
-            if (!pkceData) {
-                throw new Error('No code verifier or state for PKCE');
-            }
-            if (state !== pkceData.state) {
-                throw new Error('Provided state does not match stored state');
-            }
-            const tokenResponse = await this.getPKCEToken(authorizationCode, pkceData.verifier);
-            const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
-            const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
-            await this.userManager.storeUser(oidcUser);
-            return user;
-        }, PassportErrorType.AUTHENTICATION_ERROR);
-    }
-    async getPKCEToken(authorizationCode, codeVerifier) {
-        const response = await globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
-            client_id: this.config.oidcConfiguration.clientId,
-            grant_type: 'authorization_code',
-            code_verifier: codeVerifier,
-            code: authorizationCode,
-            redirect_uri: this.config.oidcConfiguration.redirectUri,
-        }, formUrlEncodedHeader);
-        return response.data;
+    loginWithPKCEFlowCallback(authorizationCode, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                const pkceData = this.deviceCredentialsManager.getPKCEData();
+                if (!pkceData) {
+                    throw new Error('No code verifier or state for PKCE');
+                }
+                if (state !== pkceData.state) {
+                    throw new Error('Provided state does not match stored state');
+                }
+                const tokenResponse = yield this.getPKCEToken(authorizationCode, pkceData.verifier);
+                const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+                const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+                yield this.userManager.storeUser(oidcUser);
+                return user;
+            }), PassportErrorType.AUTHENTICATION_ERROR);
+        });
     }
-    async logout() {
-        return withPassportError(async () => {
-            if (this.logoutMode === 'silent') {
-                return this.userManager.signoutSilent();
-            }
-            return this.userManager.signoutRedirect();
-        }, PassportErrorType.LOGOUT_ERROR);
+    getPKCEToken(authorizationCode, codeVerifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
+                client_id: this.config.oidcConfiguration.clientId,
+                grant_type: 'authorization_code',
+                code_verifier: codeVerifier,
+                code: authorizationCode,
+                redirect_uri: this.config.oidcConfiguration.redirectUri,
+            }, formUrlEncodedHeader);
+            return response.data;
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.logoutMode === 'silent') {
+                    return this.userManager.signoutSilent();
+                }
+                return this.userManager.signoutRedirect();
+            }), PassportErrorType.LOGOUT_ERROR);
+        });
     }
-    async removeUser() {
-        return this.userManager.removeUser();
+    removeUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.userManager.removeUser();
+        });
     }
     getDeviceFlowEndSessionEndpoint() {
         const { authenticationDomain, oidcConfiguration } = this.config;
@@ -13706,54 +13729,60 @@ class AuthManager {
         }
         return endSessionEndpoint;
     }
-    async logoutSilentCallback(url) {
-        return this.userManager.signoutSilentCallback(url);
+    logoutSilentCallback(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.userManager.signoutSilentCallback(url);
+        });
     }
     forceUserRefreshInBackground() {
         this.refreshTokenAndUpdatePromise().catch((error) => {
             logger.warn('Failed to refresh user token', error);
         });
     }
-    async forceUserRefresh() {
-        return this.refreshTokenAndUpdatePromise();
+    forceUserRefresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.refreshTokenAndUpdatePromise();
+        });
     }
     /**
      * 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) {
-                let passportErrorType = PassportErrorType.AUTHENTICATION_ERROR;
-                let errorMessage = 'Failed to refresh token';
-                if (err instanceof ErrorTimeout) {
-                    passportErrorType = PassportErrorType.SILENT_LOGIN_ERROR;
+    refreshTokenAndUpdatePromise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.refreshingPromise)
+                return this.refreshingPromise;
+            // eslint-disable-next-line no-async-promise-executor
+            this.refreshingPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const newOidcUser = yield this.userManager.signinSilent();
+                    if (newOidcUser) {
+                        resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
+                        return;
+                    }
+                    resolve(null);
                 }
-                else if (err instanceof ErrorResponse) {
-                    passportErrorType = PassportErrorType.NOT_LOGGED_IN_ERROR;
-                    errorMessage = `${err.message}: ${err.error_description}`;
+                catch (err) {
+                    let passportErrorType = PassportErrorType.AUTHENTICATION_ERROR;
+                    let errorMessage = 'Failed to refresh token';
+                    if (err instanceof ErrorTimeout) {
+                        passportErrorType = PassportErrorType.SILENT_LOGIN_ERROR;
+                    }
+                    else if (err instanceof ErrorResponse) {
+                        passportErrorType = PassportErrorType.NOT_LOGGED_IN_ERROR;
+                        errorMessage = `${err.message}: ${err.error_description}`;
+                    }
+                    else if (err instanceof Error) {
+                        errorMessage = err.message;
+                    }
+                    reject(new PassportError(errorMessage, passportErrorType));
                 }
-                else if (err instanceof Error) {
-                    errorMessage = err.message;
+                finally {
+                    this.refreshingPromise = null; // Reset the promise after completion
                 }
-                reject(new PassportError(errorMessage, passportErrorType));
-            }
-            finally {
-                this.refreshingPromise = null; // Reset the promise after completion
-            }
+            }));
+            return this.refreshingPromise;
         });
-        return this.refreshingPromise;
     }
     /**
      *
@@ -13768,46 +13797,103 @@ class AuthManager {
      * 3. Attempt to refresh the User if a refresh token is present.
      * 4. Return null if no valid User can be obtained.
      */
-    async getUser(typeAssertion = (user) => true) {
-        if (this.refreshingPromise) {
-            const user = await this.refreshingPromise;
-            if (user && typeAssertion(user)) {
-                return user;
+    getUser(typeAssertion = (user) => true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.refreshingPromise) {
+                const user = yield this.refreshingPromise;
+                if (user && typeAssertion(user)) {
+                    return user;
+                }
+                return null;
+            }
+            const oidcUser = yield this.userManager.getUser();
+            if (!oidcUser)
+                return null;
+            if (!isTokenExpired(oidcUser)) {
+                const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+                if (user && typeAssertion(user)) {
+                    return user;
+                }
+            }
+            if (oidcUser.refresh_token) {
+                const user = yield this.refreshTokenAndUpdatePromise();
+                if (user && typeAssertion(user)) {
+                    return user;
+                }
             }
             return null;
-        }
-        const oidcUser = await this.userManager.getUser();
-        if (!oidcUser)
-            return null;
-        if (!isTokenExpired(oidcUser)) {
-            const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
-            if (user && typeAssertion(user)) {
-                return user;
+        });
+    }
+    getUserZkEvm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUser(isUserZkEvm);
+            if (!user) {
+                throw new Error('Failed to obtain a User with the required ZkEvm attributes');
             }
-        }
-        if (oidcUser.refresh_token) {
-            const user = await this.refreshTokenAndUpdatePromise();
-            if (user && typeAssertion(user)) {
-                return user;
+            return user;
+        });
+    }
+    getUserImx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUser(isUserImx);
+            if (!user) {
+                throw new Error('Failed to obtain a User with the required IMX attributes');
             }
-        }
-        return null;
+            return user;
+        });
     }
-    async getUserZkEvm() {
-        const user = await this.getUser(isUserZkEvm);
-        if (!user) {
-            throw new Error('Failed to obtain a User with the required ZkEvm attributes');
-        }
-        return user;
+}
+AuthManager.mapOidcUserToDomainModel = (oidcUser) => {
+    var _a;
+    let passport;
+    if (oidcUser.id_token) {
+        passport = (_a = jwt_decode(oidcUser.id_token)) === null || _a === void 0 ? void 0 : _a.passport;
+    }
+    const user = {
+        expired: oidcUser.expired,
+        idToken: oidcUser.id_token,
+        accessToken: oidcUser.access_token,
+        refreshToken: oidcUser.refresh_token,
+        profile: {
+            sub: oidcUser.profile.sub,
+            email: oidcUser.profile.email,
+            nickname: oidcUser.profile.nickname,
+        },
+    };
+    if (passport === null || passport === void 0 ? void 0 : passport.imx_eth_address) {
+        user.imx = {
+            ethAddress: passport.imx_eth_address,
+            starkAddress: passport.imx_stark_address,
+            userAdminAddress: passport.imx_user_admin_address,
+        };
     }
-    async getUserImx() {
-        const user = await this.getUser(isUserImx);
-        if (!user) {
-            throw new Error('Failed to obtain a User with the required IMX attributes');
-        }
-        return user;
+    if (passport === null || passport === void 0 ? void 0 : passport.zkevm_eth_address) {
+        user.zkEvm = {
+            ethAddress: passport === null || passport === void 0 ? void 0 : passport.zkevm_eth_address,
+            userAdminAddress: passport === null || passport === void 0 ? void 0 : passport.zkevm_user_admin_address,
+        };
     }
-}
+    return user;
+};
+AuthManager.mapDeviceTokenResponseToOidcUser = (tokenResponse) => {
+    const idTokenPayload = jwt_decode(tokenResponse.id_token);
+    return new 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,
+        },
+    });
+};
 
 const lazyLoad = (promiseToAwait, initialiseFunction) => promiseToAwait().then(initialiseFunction);
 const lazyDocumentReady = (initialiseFunction) => {
@@ -13830,8 +13916,6 @@ const lazyDocumentReady = (initialiseFunction) => {
 
 const MAINNET = 'mainnet';
 class MagicAdapter {
-    config;
-    lazyMagicClient;
     constructor(config) {
         this.config = config;
         if (typeof window !== 'undefined') {
@@ -13851,320 +13935,341 @@ class MagicAdapter {
         }
         return this.lazyMagicClient;
     }
-    async login(idToken) {
-        return withPassportError(async () => {
-            const magicClient = await this.magicClient;
-            await magicClient.openid.loginWithOIDC({
-                jwt: idToken,
-                providerId: this.config.magicProviderId,
-            });
-            return magicClient.rpcProvider;
-        }, PassportErrorType.WALLET_CONNECTION_ERROR);
+    login(idToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+                const magicClient = yield this.magicClient;
+                yield magicClient.openid.loginWithOIDC({
+                    jwt: idToken,
+                    providerId: this.config.magicProviderId,
+                });
+                return magicClient.rpcProvider;
+            }), PassportErrorType.WALLET_CONNECTION_ERROR);
+        });
     }
-    async logout() {
-        const magicClient = await this.magicClient;
-        if (magicClient.user) {
-            await magicClient.user.logout();
-        }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const magicClient = yield this.magicClient;
+            if (magicClient.user) {
+                yield magicClient.user.logout();
+            }
+        });
     }
 }
 
-const getStarkSigner = async (signer) => withPassportError(async () => {
-    const privateKey = await generateLegacyStarkPrivateKey(signer);
-    return createStarkSigner(privateKey);
-}, PassportErrorType.WALLET_CONNECTION_ERROR);
-
-async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
-    return withPassportError(async () => {
-        const { ethAddress } = user.imx;
-        const transferAmount = request.amount;
-        const signableResult = await exchangesApi.getExchangeSignableTransfer({
-            id: request.transactionID,
-            getSignableTransferRequest: {
-                sender: ethAddress,
-                token: convertToSignableToken(request),
-                amount: transferAmount,
-                receiver: request.receiver,
-            },
-        });
-        const starkAddress = await starkSigner.getAddress();
-        const { payload_hash: payloadHash } = signableResult.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
-            sender_vault_id: signableResult.data.sender_vault_id,
-            receiver_stark_key: signableResult.data.receiver_stark_key,
-            receiver_vault_id: signableResult.data.receiver_vault_id,
-            asset_id: signableResult.data.asset_id,
-            amount: signableResult.data.amount,
-            nonce: signableResult.data.nonce,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
-        const response = await exchangesApi.createExchangeTransfer({
-            id: request.transactionID,
-            createTransferRequest: transferSigningParams,
-        }, { headers });
-        return {
-            sent_signature: response?.data.sent_signature,
-            status: response?.data.status?.toString(),
-            time: response?.data.time,
-            transfer_id: response?.data.transfer_id,
-        };
-    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+const getStarkSigner = (signer) => __awaiter(void 0, void 0, void 0, function* () {
+    return withPassportError(() => __awaiter(void 0, void 0, void 0, function* () {
+        const privateKey = yield generateLegacyStarkPrivateKey(signer);
+        return createStarkSigner(privateKey);
+    }), PassportErrorType.WALLET_CONNECTION_ERROR);
+});
+
+function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { ethAddress } = user.imx;
+            const transferAmount = request.amount;
+            const signableResult = yield exchangesApi.getExchangeSignableTransfer({
+                id: request.transactionID,
+                getSignableTransferRequest: {
+                    sender: ethAddress,
+                    token: convertToSignableToken(request),
+                    amount: transferAmount,
+                    receiver: request.receiver,
+                },
+            });
+            const starkAddress = yield starkSigner.getAddress();
+            const { payload_hash: payloadHash } = signableResult.data;
+            const starkSignature = yield starkSigner.signMessage(payloadHash);
+            const transferSigningParams = {
+                sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
+                sender_vault_id: signableResult.data.sender_vault_id,
+                receiver_stark_key: signableResult.data.receiver_stark_key,
+                receiver_vault_id: signableResult.data.receiver_vault_id,
+                asset_id: signableResult.data.asset_id,
+                amount: signableResult.data.amount,
+                nonce: signableResult.data.nonce,
+                expiration_timestamp: signableResult.data.expiration_timestamp,
+                stark_signature: starkSignature,
+            };
+            const headers = {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                Authorization: `Bearer ${user.accessToken}`,
+            };
+            const response = yield exchangesApi.createExchangeTransfer({
+                id: request.transactionID,
+                createTransferRequest: transferSigningParams,
+            }, { headers });
+            return {
+                sent_signature: response === null || response === void 0 ? void 0 : response.data.sent_signature,
+                status: (_a = response === null || response === void 0 ? void 0 : response.data.status) === null || _a === void 0 ? void 0 : _a.toString(),
+                time: response === null || response === void 0 ? void 0 : response.data.time,
+                transfer_id: response === null || response === void 0 ? void 0 : response.data.transfer_id,
+            };
+        }), PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+    });
 }
 
 const ERC721$1 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
-        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 = { Authorization: `Bearer ${user.accessToken}` };
-        const getSignableOrderRequestV3 = {
-            user: ethAddress,
-            amount_buy: amountBuy,
-            token_buy: convertToSignableToken(request.buy),
-            amount_sell: amountSell,
-            token_sell: convertToSignableToken(request.sell),
-            fees: request.fees,
-            split_fees: true,
-            expiration_timestamp: request.expiration_timestamp,
-        };
-        const getSignableOrderResponse = await ordersApi.getSignableOrder({
-            getSignableOrderRequestV3,
-        }, { headers });
-        await guardianClient.evaluateImxTransaction({
-            payloadHash: getSignableOrderResponse.data.payload_hash,
-        });
-        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const signableResultData = getSignableOrderResponse.data;
-        const orderParams = {
-            createOrderRequest: {
-                include_fees: true,
+function createOrder({ starkSigner, user, request, ordersApi, guardianClient, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(guardianClient.withDefaultConfirmationScreenTask(() => __awaiter(this, void 0, void 0, function* () {
+            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 = { Authorization: `Bearer ${user.accessToken}` };
+            const getSignableOrderRequestV3 = {
+                user: ethAddress,
+                amount_buy: amountBuy,
+                token_buy: convertToSignableToken(request.buy),
+                amount_sell: amountSell,
+                token_sell: convertToSignableToken(request.sell),
                 fees: request.fees,
-                stark_signature: starkSignature,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
-            },
-        };
-        const createOrderResponse = await ordersApi.createOrderV3(orderParams, {
-            headers,
-        });
-        return {
-            ...createOrderResponse.data,
-        };
-    }), PassportErrorType.CREATE_ORDER_ERROR);
+                split_fees: true,
+                expiration_timestamp: request.expiration_timestamp,
+            };
+            const getSignableOrderResponse = yield ordersApi.getSignableOrder({
+                getSignableOrderRequestV3,
+            }, { headers });
+            yield guardianClient.evaluateImxTransaction({
+                payloadHash: getSignableOrderResponse.data.payload_hash,
+            });
+            const { payload_hash: payloadHash } = getSignableOrderResponse.data;
+            const starkSignature = yield starkSigner.signMessage(payloadHash);
+            const signableResultData = getSignableOrderResponse.data;
+            const orderParams = {
+                createOrderRequest: {
+                    include_fees: true,
+                    fees: request.fees,
+                    stark_signature: starkSignature,
+                    amount_buy: signableResultData.amount_buy,
+                    amount_sell: signableResultData.amount_sell,
+                    asset_id_buy: signableResultData.asset_id_buy,
+                    asset_id_sell: signableResultData.asset_id_sell,
+                    expiration_timestamp: signableResultData.expiration_timestamp,
+                    nonce: signableResultData.nonce,
+                    stark_key: signableResultData.stark_key,
+                    vault_id_buy: signableResultData.vault_id_buy,
+                    vault_id_sell: signableResultData.vault_id_sell,
+                },
+            };
+            const createOrderResponse = yield ordersApi.createOrderV3(orderParams, {
+                headers,
+            });
+            return Object.assign({}, createOrderResponse.data);
+        })), PassportErrorType.CREATE_ORDER_ERROR);
+    });
 }
-async function cancelOrder({ user, starkSigner, request, ordersApi, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
-        const getSignableCancelOrderRequest = {
-            order_id: request.order_id,
-        };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
-        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
-            getSignableCancelOrderRequest,
-        }, { headers });
-        await guardianClient.evaluateImxTransaction({
-            payloadHash: getSignableCancelOrderResponse.data.payload_hash,
-        });
-        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const cancelOrderResponse = await ordersApi.cancelOrderV3({
-            id: request.order_id.toString(),
-            cancelOrderRequest: {
+function cancelOrder({ user, starkSigner, request, ordersApi, guardianClient, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(guardianClient.withDefaultConfirmationScreenTask(() => __awaiter(this, void 0, void 0, function* () {
+            const getSignableCancelOrderRequest = {
                 order_id: request.order_id,
-                stark_signature: starkSignature,
-            },
-        }, { headers });
-        return {
-            order_id: cancelOrderResponse.data.order_id,
-            status: cancelOrderResponse.data.status,
-        };
-    }), PassportErrorType.CANCEL_ORDER_ERROR);
-}
-
-async function registerPassport({ ethSigner, starkSigner, imxApiClients }, authorization) {
-    const [userAddress, starkPublicKey] = await Promise.all([
-        ethSigner.getAddress(),
-        starkSigner.getAddress(),
-    ]);
-    const signableResult = await imxApiClients.usersApi.getSignableRegistrationOffchain({
-        getSignableRegistrationRequest: {
-            ether_key: userAddress,
-            stark_key: starkPublicKey,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const [ethSignature, starkSignature] = await Promise.all([
-        signRaw(signableMessage, ethSigner),
-        starkSigner.signMessage(payloadHash),
-    ]);
-    const response = await imxApiClients.usersApi.registerPassportUserV2({
-        authorization: `Bearer ${authorization}`,
-        registerPassportUserRequest: {
-            eth_signature: ethSignature,
-            ether_key: userAddress,
-            stark_signature: starkSignature,
-            stark_key: starkPublicKey,
-        },
+            };
+            const headers = {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                Authorization: `Bearer ${user.accessToken}`,
+            };
+            const getSignableCancelOrderResponse = yield ordersApi.getSignableCancelOrderV3({
+                getSignableCancelOrderRequest,
+            }, { headers });
+            yield guardianClient.evaluateImxTransaction({
+                payloadHash: getSignableCancelOrderResponse.data.payload_hash,
+            });
+            const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+            const starkSignature = yield starkSigner.signMessage(payloadHash);
+            const cancelOrderResponse = yield ordersApi.cancelOrderV3({
+                id: request.order_id.toString(),
+                cancelOrderRequest: {
+                    order_id: request.order_id,
+                    stark_signature: starkSignature,
+                },
+            }, { headers });
+            return {
+                order_id: cancelOrderResponse.data.order_id,
+                status: cancelOrderResponse.data.status,
+            };
+        })), PassportErrorType.CANCEL_ORDER_ERROR);
     });
-    return response.data;
 }
 
-async function createTrade({ request, tradesApi, user, starkSigner, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
-        const { ethAddress } = user.imx;
-        const getSignableTradeRequest = {
-            expiration_timestamp: request.expiration_timestamp,
-            fees: request.fees,
-            order_id: request.order_id,
-            user: ethAddress,
-        };
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const getSignableTradeResponse = await tradesApi.getSignableTrade({
-            getSignableTradeRequest,
-        }, { headers });
-        await guardianClient.evaluateImxTransaction({
-            payloadHash: getSignableTradeResponse.data.payload_hash,
+function registerPassport({ ethSigner, starkSigner, imxApiClients }, authorization) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [userAddress, starkPublicKey] = yield Promise.all([
+            ethSigner.getAddress(),
+            starkSigner.getAddress(),
+        ]);
+        const signableResult = yield imxApiClients.usersApi.getSignableRegistrationOffchain({
+            getSignableRegistrationRequest: {
+                ether_key: userAddress,
+                stark_key: starkPublicKey,
+            },
         });
-        const { payload_hash: payloadHash } = getSignableTradeResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const { data: signableResultData } = getSignableTradeResponse;
-        const tradeParams = {
-            createTradeRequest: {
-                include_fees: true,
-                fees: request?.fees,
+        const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+        const [ethSignature, starkSignature] = yield Promise.all([
+            signRaw(signableMessage, ethSigner),
+            starkSigner.signMessage(payloadHash),
+        ]);
+        const response = yield imxApiClients.usersApi.registerPassportUserV2({
+            authorization: `Bearer ${authorization}`,
+            registerPassportUserRequest: {
+                eth_signature: ethSignature,
+                ether_key: userAddress,
                 stark_signature: starkSignature,
-                order_id: request?.order_id,
-                fee_info: signableResultData.fee_info,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
+                stark_key: starkPublicKey,
             },
-        };
-        const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
-            headers,
         });
-        return createTradeResponse;
-    }), PassportErrorType.CREATE_TRADE_ERROR);
+        return response.data;
+    });
+}
+
+function createTrade({ request, tradesApi, user, starkSigner, guardianClient, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(guardianClient.withDefaultConfirmationScreenTask(() => __awaiter(this, void 0, void 0, function* () {
+            const { ethAddress } = user.imx;
+            const getSignableTradeRequest = {
+                expiration_timestamp: request.expiration_timestamp,
+                fees: request.fees,
+                order_id: request.order_id,
+                user: ethAddress,
+            };
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const headers = { Authorization: `Bearer ${user.accessToken}` };
+            const getSignableTradeResponse = yield tradesApi.getSignableTrade({
+                getSignableTradeRequest,
+            }, { headers });
+            yield guardianClient.evaluateImxTransaction({
+                payloadHash: getSignableTradeResponse.data.payload_hash,
+            });
+            const { payload_hash: payloadHash } = getSignableTradeResponse.data;
+            const starkSignature = yield starkSigner.signMessage(payloadHash);
+            const { data: signableResultData } = getSignableTradeResponse;
+            const tradeParams = {
+                createTradeRequest: {
+                    include_fees: true,
+                    fees: request === null || request === void 0 ? void 0 : request.fees,
+                    stark_signature: starkSignature,
+                    order_id: request === null || request === void 0 ? void 0 : request.order_id,
+                    fee_info: signableResultData.fee_info,
+                    amount_buy: signableResultData.amount_buy,
+                    amount_sell: signableResultData.amount_sell,
+                    asset_id_buy: signableResultData.asset_id_buy,
+                    asset_id_sell: signableResultData.asset_id_sell,
+                    expiration_timestamp: signableResultData.expiration_timestamp,
+                    nonce: signableResultData.nonce,
+                    stark_key: signableResultData.stark_key,
+                    vault_id_buy: signableResultData.vault_id_buy,
+                    vault_id_sell: signableResultData.vault_id_sell,
+                },
+            };
+            const { data: createTradeResponse } = yield tradesApi.createTradeV3(tradeParams, {
+                headers,
+            });
+            return createTradeResponse;
+        })), PassportErrorType.CREATE_TRADE_ERROR);
+    });
 }
 
 const ERC721 = 'ERC721';
-async function transfer({ request, transfersApi, starkSigner, user, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
-        const transferAmount = request.type === ERC721 ? '1' : request.amount;
-        const getSignableTransferRequest = {
-            sender: user.imx.ethAddress,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
-        };
-        const headers = {
-            Authorization: `Bearer ${user.accessToken}`,
-        };
-        const signableResult = await transfersApi.getSignableTransferV1({
-            getSignableTransferRequest,
-        }, { headers });
-        await guardianClient.evaluateImxTransaction({
-            payloadHash: signableResult.data.payload_hash,
-        });
-        const signableResultData = signableResult.data;
-        const { payload_hash: payloadHash } = signableResultData;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const senderStarkKey = await starkSigner.getAddress();
-        const transferSigningParams = {
-            sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
-            sender_vault_id: signableResultData.sender_vault_id,
-            receiver_stark_key: signableResultData.receiver_stark_key,
-            receiver_vault_id: signableResultData.receiver_vault_id,
-            asset_id: signableResultData.asset_id,
-            amount: signableResultData.amount,
-            nonce: signableResultData.nonce,
-            expiration_timestamp: signableResultData.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const createTransferRequest = {
-            createTransferRequest: transferSigningParams,
-        };
-        const { data: responseData } = await transfersApi.createTransferV1(createTransferRequest, { headers });
-        return {
-            sent_signature: responseData.sent_signature,
-            status: responseData.status?.toString(),
-            time: responseData.time,
-            transfer_id: responseData.transfer_id,
-        };
-    }), PassportErrorType.TRANSFER_ERROR);
+function transfer({ request, transfersApi, starkSigner, user, guardianClient, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(guardianClient.withDefaultConfirmationScreenTask(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const transferAmount = request.type === ERC721 ? '1' : request.amount;
+            const getSignableTransferRequest = {
+                sender: user.imx.ethAddress,
+                token: convertToSignableToken(request),
+                amount: transferAmount,
+                receiver: request.receiver,
+            };
+            const headers = {
+                Authorization: `Bearer ${user.accessToken}`,
+            };
+            const signableResult = yield transfersApi.getSignableTransferV1({
+                getSignableTransferRequest,
+            }, { headers });
+            yield guardianClient.evaluateImxTransaction({
+                payloadHash: signableResult.data.payload_hash,
+            });
+            const signableResultData = signableResult.data;
+            const { payload_hash: payloadHash } = signableResultData;
+            const starkSignature = yield starkSigner.signMessage(payloadHash);
+            const senderStarkKey = yield starkSigner.getAddress();
+            const transferSigningParams = {
+                sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
+                sender_vault_id: signableResultData.sender_vault_id,
+                receiver_stark_key: signableResultData.receiver_stark_key,
+                receiver_vault_id: signableResultData.receiver_vault_id,
+                asset_id: signableResultData.asset_id,
+                amount: signableResultData.amount,
+                nonce: signableResultData.nonce,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                stark_signature: starkSignature,
+            };
+            const createTransferRequest = {
+                createTransferRequest: transferSigningParams,
+            };
+            const { data: responseData } = yield transfersApi.createTransferV1(createTransferRequest, { headers });
+            return {
+                sent_signature: responseData.sent_signature,
+                status: (_a = responseData.status) === null || _a === void 0 ? void 0 : _a.toString(),
+                time: responseData.time,
+                transfer_id: responseData.transfer_id,
+            };
+        })), PassportErrorType.TRANSFER_ERROR);
+    });
 }
-async function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }) {
-    // eslint-disable-next-line function-paren-newline
-    return withPassportError(guardianClient.withConfirmationScreenTask({ width: 480, height: 784 })(async () => {
-        const { ethAddress } = user.imx;
-        const signableRequests = request.map((nftTransfer) => ({
-            amount: '1',
-            token: convertToSignableToken({
-                type: ERC721,
-                tokenId: nftTransfer.tokenId,
-                tokenAddress: nftTransfer.tokenAddress,
-            }),
-            receiver: nftTransfer.receiver,
-        }));
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const signableResult = await transfersApi.getSignableTransfer({
-            getSignableTransferRequestV2: {
-                sender_ether_key: ethAddress,
-                signable_requests: signableRequests,
-            },
-        }, { headers });
-        await guardianClient.evaluateImxTransaction({
-            payloadHash: signableResult.data.signable_responses[0]?.payload_hash,
-        });
-        const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
-            const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // eslint-disable-next-line function-paren-newline
+        return withPassportError(guardianClient.withConfirmationScreenTask({ width: 480, height: 784 })(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { ethAddress } = user.imx;
+            const signableRequests = request.map((nftTransfer) => ({
+                amount: '1',
+                token: convertToSignableToken({
+                    type: ERC721,
+                    tokenId: nftTransfer.tokenId,
+                    tokenAddress: nftTransfer.tokenAddress,
+                }),
+                receiver: nftTransfer.receiver,
+            }));
+            const headers = { Authorization: `Bearer ${user.accessToken}` };
+            const signableResult = yield transfersApi.getSignableTransfer({
+                getSignableTransferRequestV2: {
+                    sender_ether_key: ethAddress,
+                    signable_requests: signableRequests,
+                },
+            }, { headers });
+            yield guardianClient.evaluateImxTransaction({
+                payloadHash: (_a = signableResult.data.signable_responses[0]) === null || _a === void 0 ? void 0 : _a.payload_hash,
+            });
+            const requests = yield Promise.all(signableResult.data.signable_responses.map((resp) => __awaiter(this, void 0, void 0, function* () {
+                const starkSignature = yield starkSigner.signMessage(resp.payload_hash);
+                return {
+                    sender_vault_id: resp.sender_vault_id,
+                    receiver_stark_key: resp.receiver_stark_key,
+                    receiver_vault_id: resp.receiver_vault_id,
+                    asset_id: resp.asset_id,
+                    amount: resp.amount,
+                    nonce: resp.nonce,
+                    expiration_timestamp: resp.expiration_timestamp,
+                    stark_signature: starkSignature,
+                };
+            })));
+            const transferSigningParams = {
+                sender_stark_key: signableResult.data.sender_stark_key,
+                requests,
+            };
+            const response = yield transfersApi.createTransfer({
+                createTransferRequestV2: transferSigningParams,
+            }, { headers });
             return {
-                sender_vault_id: resp.sender_vault_id,
-                receiver_stark_key: resp.receiver_stark_key,
-                receiver_vault_id: resp.receiver_vault_id,
-                asset_id: resp.asset_id,
-                amount: resp.amount,
-                nonce: resp.nonce,
-                expiration_timestamp: resp.expiration_timestamp,
-                stark_signature: starkSignature,
+                transfer_ids: response === null || response === void 0 ? void 0 : response.data.transfer_ids,
             };
-        }));
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key,
-            requests,
-        };
-        const response = await transfersApi.createTransfer({
-            createTransferRequestV2: transferSigningParams,
-        }, { headers });
-        return {
-            transfer_ids: response?.data.transfer_ids,
-        };
-    }), PassportErrorType.TRANSFER_ERROR);
+        })), PassportErrorType.TRANSFER_ERROR);
+    });
 }
 
 const POLL_INTERVAL = 1 * 1000; // every 1 second
@@ -14172,16 +14277,16 @@ const MAX_RETRIES = 3;
 const wait = (ms) => new Promise((resolve) => {
     setTimeout(() => resolve(), ms);
 });
-const retryWithDelay = async (fn, options) => {
+const retryWithDelay = (fn, options) => __awaiter(void 0, void 0, void 0, function* () {
     const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), finallyFn = () => { }, } = options || {};
     try {
-        return await fn();
+        return yield fn();
     }
     catch (err) {
         if (retries <= 0) {
             return Promise.reject(finalErr);
         }
-        await wait(interval);
+        yield wait(interval);
         return retryWithDelay(fn, { retries: retries - 1, finalErr, finallyFn });
     }
     finally {
@@ -14189,203 +14294,147 @@ const retryWithDelay = async (fn, options) => {
             finallyFn();
         }
     }
-};
+});
 
-async function forceUserRefresh(authManager) {
-    // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
-    await retryWithDelay(async () => {
-        const user = await authManager.forceUserRefresh(); // force refresh to get updated user info
-        if (user?.imx)
-            return user;
-        return Promise.reject(new Error('user wallet addresses not exist'));
+function forceUserRefresh(authManager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
+        yield retryWithDelay(() => __awaiter(this, void 0, void 0, function* () {
+            const user = yield authManager.forceUserRefresh(); // force refresh to get updated user info
+            if (user === null || user === void 0 ? void 0 : user.imx)
+                return user;
+            return Promise.reject(new Error('user wallet addresses not exist'));
+        }));
     });
 }
-async function registerOffchain(userAdminKeySigner, starkSigner, unregisteredUser, authManager, imxApiClients) {
-    return withPassportError(async () => {
-        try {
-            const response = await registerPassport({
-                ethSigner: userAdminKeySigner,
-                starkSigner,
-                imxApiClients,
-            }, unregisteredUser.accessToken);
-            await forceUserRefresh(authManager);
-            return response;
-        }
-        catch (err) {
-            if (globalAxios$1.isAxiosError(err) && err.response?.status === 409) {
-                // The user already registered, but the user token is not updated yet.
-                await forceUserRefresh(authManager);
-                return { tx_hash: '' };
+function registerOffchain(userAdminKeySigner, starkSigner, unregisteredUser, authManager, imxApiClients) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withPassportError(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const response = yield registerPassport({
+                    ethSigner: userAdminKeySigner,
+                    starkSigner,
+                    imxApiClients,
+                }, unregisteredUser.accessToken);
+                yield forceUserRefresh(authManager);
+                return response;
             }
-            throw err;
-        }
-    }, PassportErrorType.USER_REGISTRATION_ERROR);
+            catch (err) {
+                if (globalAxios$1.isAxiosError(err) && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 409) {
+                    // The user already registered, but the user token is not updated yet.
+                    yield forceUserRefresh(authManager);
+                    return { tx_hash: '' };
+                }
+                throw err;
+            }
+        }), PassportErrorType.USER_REGISTRATION_ERROR);
+    });
 }
 
+var _PassportImxProvider_instances, _PassportImxProvider_initialiseSigners, _PassportImxProvider_getAuthenticatedUser, _PassportImxProvider_getSigners, _PassportImxProvider_getRegisteredImxUserAndSigners;
 class PassportImxProvider {
-    authManager;
-    immutableXClient;
-    guardianClient;
-    imxApiClients;
-    magicAdapter;
-    /**
-     * This property is set during initialisation and stores the signers in a promise.
-     * This property is not meant to be accessed directly, but through the
-     * `#getSigners` method.
-     * @see #getSigners
-     */
-    signers;
-    signerInitialisationError;
     constructor({ authManager, immutableXClient, passportEventEmitter, magicAdapter, imxApiClients, guardianClient, }) {
+        _PassportImxProvider_instances.add(this);
+        this.handleLogout = () => {
+            this.signers = undefined;
+        };
         this.authManager = authManager;
         this.immutableXClient = immutableXClient;
         this.magicAdapter = magicAdapter;
         this.imxApiClients = imxApiClients;
         this.guardianClient = guardianClient;
-        this.#initialiseSigners();
+        __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_initialiseSigners).call(this);
         passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
     }
-    handleLogout = () => {
-        this.signers = undefined;
-    };
-    /**
-     * This method is called by the constructor and asynchronously initialises the signers.
-     * The signers are stored in a promise so that they can be retrieved by the provider
-     * when needed.
-     *
-     * If an error is thrown during initialisation, it is stored in the `signerInitialisationError`,
-     * so that it doesn't result in an unhandled promise rejection.
-     *
-     * This error is thrown when the signers are requested through:
-     * @see #getSigners
-     *
-     */
-    #initialiseSigners() {
-        const generateSigners = async () => {
-            const user = await this.authManager.getUser();
-            // The user will be present because the factory validates it
-            const magicRpcProvider = await this.magicAdapter.login(user.idToken);
-            const web3Provider = new Web3Provider(magicRpcProvider);
-            const ethSigner = web3Provider.getSigner();
-            const starkSigner = await getStarkSigner(ethSigner);
-            return { ethSigner, starkSigner };
-        };
-        // eslint-disable-next-line no-async-promise-executor
-        this.signers = new Promise(async (resolve) => {
-            try {
-                resolve(await generateSigners());
-            }
-            catch (err) {
-                // Capture and store the initialization error
-                this.signerInitialisationError = err;
-                resolve(undefined);
-            }
+    transfer(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return transfer({
+                request,
+                user,
+                starkSigner,
+                transfersApi: this.immutableXClient.transfersApi,
+                guardianClient: this.guardianClient,
+            });
         });
     }
-    async #getAuthenticatedUser() {
-        const user = await this.authManager.getUser();
-        if (!user || !this.signers) {
-            throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
-        }
-        return user;
-    }
-    async #getSigners() {
-        const signers = await this.signers;
-        // Throw the stored error if the signers failed to initialise
-        if (typeof signers === 'undefined') {
-            if (typeof this.signerInitialisationError !== 'undefined') {
-                throw this.signerInitialisationError;
-            }
-            throw new Error('Signers failed to initialise');
-        }
-        return signers;
-    }
-    async #getRegisteredImxUserAndSigners() {
-        const [user, signers] = await Promise.all([
-            this.#getAuthenticatedUser(),
-            this.#getSigners(),
-        ]);
-        if (!isUserImx(user)) {
-            throw new PassportError('User has not been registered with StarkEx', PassportErrorType.USER_NOT_REGISTERED_ERROR);
-        }
-        return {
-            user,
-            starkSigner: signers.starkSigner,
-            ethSigner: signers.ethSigner,
-        };
-    }
-    async transfer(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return transfer({
-            request,
-            user,
-            starkSigner,
-            transfersApi: this.immutableXClient.transfersApi,
-            guardianClient: this.guardianClient,
+    registerOffchain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [user, signers] = yield Promise.all([
+                __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getAuthenticatedUser).call(this),
+                __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getSigners).call(this),
+            ]);
+            return yield registerOffchain(signers.ethSigner, signers.starkSigner, user, this.authManager, this.imxApiClients);
         });
     }
-    async registerOffchain() {
-        const [user, signers] = await Promise.all([
-            this.#getAuthenticatedUser(),
-            this.#getSigners(),
-        ]);
-        return await registerOffchain(signers.ethSigner, signers.starkSigner, user, this.authManager, this.imxApiClients);
-    }
-    async isRegisteredOffchain() {
-        const user = await this.#getAuthenticatedUser();
-        return !!user.imx;
+    isRegisteredOffchain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getAuthenticatedUser).call(this);
+            return !!user.imx;
+        });
     }
     // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    async createOrder(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return createOrder({
-            request,
-            user,
-            starkSigner,
-            ordersApi: this.immutableXClient.ordersApi,
-            guardianClient: this.guardianClient,
+    createOrder(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return createOrder({
+                request,
+                user,
+                starkSigner,
+                ordersApi: this.immutableXClient.ordersApi,
+                guardianClient: this.guardianClient,
+            });
         });
     }
-    async cancelOrder(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return cancelOrder({
-            request,
-            user,
-            starkSigner,
-            ordersApi: this.immutableXClient.ordersApi,
-            guardianClient: this.guardianClient,
+    cancelOrder(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return cancelOrder({
+                request,
+                user,
+                starkSigner,
+                ordersApi: this.immutableXClient.ordersApi,
+                guardianClient: this.guardianClient,
+            });
         });
     }
-    async createTrade(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return createTrade({
-            request,
-            user,
-            starkSigner,
-            tradesApi: this.immutableXClient.tradesApi,
-            guardianClient: this.guardianClient,
+    createTrade(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return createTrade({
+                request,
+                user,
+                starkSigner,
+                tradesApi: this.immutableXClient.tradesApi,
+                guardianClient: this.guardianClient,
+            });
         });
     }
-    async batchNftTransfer(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return batchNftTransfer({
-            request,
-            user,
-            starkSigner,
-            transfersApi: this.immutableXClient.transfersApi,
-            guardianClient: this.guardianClient,
+    batchNftTransfer(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return batchNftTransfer({
+                request,
+                user,
+                starkSigner,
+                transfersApi: this.immutableXClient.transfersApi,
+                guardianClient: this.guardianClient,
+            });
         });
     }
-    async exchangeTransfer(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return exchangeTransfer({
-            request,
-            user,
-            starkSigner,
-            exchangesApi: this.immutableXClient.exchangeApi,
+    exchangeTransfer(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { user, starkSigner } = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getRegisteredImxUserAndSigners).call(this);
+            return exchangeTransfer({
+                request,
+                user,
+                starkSigner,
+                exchangesApi: this.immutableXClient.exchangeApi,
+            });
         });
     }
     // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
@@ -14404,22 +14453,75 @@ class PassportImxProvider {
     token) {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    async getAddress() {
-        const user = await this.#getAuthenticatedUser();
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getAuthenticatedUser).call(this);
+            if (!isUserImx(user)) {
+                throw new PassportError('User has not been registered with StarkEx', PassportErrorType.USER_NOT_REGISTERED_ERROR);
+            }
+            return Promise.resolve(user.imx.ethAddress);
+        });
+    }
+}
+_PassportImxProvider_instances = new WeakSet(), _PassportImxProvider_initialiseSigners = function _PassportImxProvider_initialiseSigners() {
+    const generateSigners = () => __awaiter(this, void 0, void 0, function* () {
+        const user = yield this.authManager.getUser();
+        // The user will be present because the factory validates it
+        const magicRpcProvider = yield this.magicAdapter.login(user.idToken);
+        const web3Provider = new Web3Provider(magicRpcProvider);
+        const ethSigner = web3Provider.getSigner();
+        const starkSigner = yield getStarkSigner(ethSigner);
+        return { ethSigner, starkSigner };
+    });
+    // eslint-disable-next-line no-async-promise-executor
+    this.signers = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            resolve(yield generateSigners());
+        }
+        catch (err) {
+            // Capture and store the initialization error
+            this.signerInitialisationError = err;
+            resolve(undefined);
+        }
+    }));
+}, _PassportImxProvider_getAuthenticatedUser = function _PassportImxProvider_getAuthenticatedUser() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const user = yield this.authManager.getUser();
+        if (!user || !this.signers) {
+            throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
+        }
+        return user;
+    });
+}, _PassportImxProvider_getSigners = function _PassportImxProvider_getSigners() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const signers = yield this.signers;
+        // Throw the stored error if the signers failed to initialise
+        if (typeof signers === 'undefined') {
+            if (typeof this.signerInitialisationError !== 'undefined') {
+                throw this.signerInitialisationError;
+            }
+            throw new Error('Signers failed to initialise');
+        }
+        return signers;
+    });
+}, _PassportImxProvider_getRegisteredImxUserAndSigners = function _PassportImxProvider_getRegisteredImxUserAndSigners() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [user, signers] = yield Promise.all([
+            __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getAuthenticatedUser).call(this),
+            __classPrivateFieldGet(this, _PassportImxProvider_instances, "m", _PassportImxProvider_getSigners).call(this),
+        ]);
         if (!isUserImx(user)) {
             throw new PassportError('User has not been registered with StarkEx', PassportErrorType.USER_NOT_REGISTERED_ERROR);
         }
-        return Promise.resolve(user.imx.ethAddress);
-    }
-}
+        return {
+            user,
+            starkSigner: signers.starkSigner,
+            ethSigner: signers.ethSigner,
+        };
+    });
+};
 
 class PassportImxProviderFactory {
-    authManager;
-    immutableXClient;
-    magicAdapter;
-    passportEventEmitter;
-    imxApiClients;
-    guardianClient;
     constructor({ authManager, immutableXClient, magicAdapter, passportEventEmitter, imxApiClients, guardianClient, }) {
         this.authManager = authManager;
         this.immutableXClient = immutableXClient;
@@ -14428,28 +14530,34 @@ class PassportImxProviderFactory {
         this.imxApiClients = imxApiClients;
         this.guardianClient = guardianClient;
     }
-    async getProvider() {
-        const user = await this.authManager.getUserOrLogin();
-        return this.createProviderInstance(user);
+    getProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUserOrLogin();
+            return this.createProviderInstance(user);
+        });
     }
-    async getProviderSilent() {
-        const user = await this.authManager.getUser();
-        if (!user) {
-            return null;
-        }
-        return this.createProviderInstance(user);
+    getProviderSilent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUser();
+            if (!user) {
+                return null;
+            }
+            return this.createProviderInstance(user);
+        });
     }
-    async createProviderInstance(user) {
-        if (!user.idToken) {
-            throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
-        }
-        return new PassportImxProvider({
-            authManager: this.authManager,
-            immutableXClient: this.immutableXClient,
-            passportEventEmitter: this.passportEventEmitter,
-            magicAdapter: this.magicAdapter,
-            imxApiClients: this.imxApiClients,
-            guardianClient: this.guardianClient,
+    createProviderInstance(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!user.idToken) {
+                throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
+            }
+            return new PassportImxProvider({
+                authManager: this.authManager,
+                immutableXClient: this.immutableXClient,
+                passportEventEmitter: this.passportEventEmitter,
+                magicAdapter: this.magicAdapter,
+                imxApiClients: this.imxApiClients,
+                guardianClient: this.guardianClient,
+            });
         });
     }
 }
@@ -14467,18 +14575,8 @@ const validateConfiguration = (configuration, requiredKeys, prefix) => {
     }
 };
 class PassportConfiguration {
-    authenticationDomain;
-    passportDomain;
-    imxPublicApiDomain;
-    magicPublishableApiKey;
-    magicProviderId;
-    oidcConfiguration;
-    baseConfig;
-    zkEvmRpcUrl;
-    relayerUrl;
-    multiRollupConfig;
-    crossSdkBridgeEnabled;
-    constructor({ baseConfig, overrides, crossSdkBridgeEnabled, ...oidcConfiguration }) {
+    constructor(_a) {
+        var { baseConfig, overrides, crossSdkBridgeEnabled } = _a, oidcConfiguration = __rest(_a, ["baseConfig", "overrides", "crossSdkBridgeEnabled"]);
         validateConfiguration(oidcConfiguration, [
             'clientId',
             'redirectUri',
@@ -14583,8 +14681,6 @@ const CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION = 1000;
 const CONFIRMATION_IFRAME_ID = 'passport-confirm';
 const CONFIRMATION_IFRAME_STYLE = 'display: none; position: absolute;width:0px;height:0px;border:0;';
 class ConfirmationScreen {
-    config;
-    confirmationWindow;
     constructor(config) {
         this.config = config;
     }
@@ -14680,12 +14776,13 @@ class ConfirmationScreen {
         this.confirmationWindow = openPopupCenter({
             url: this.getHref('loading'),
             title: CONFIRMATION_WINDOW_TITLE,
-            width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
-            height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+            width: (popupOptions === null || popupOptions === void 0 ? void 0 : popupOptions.width) || CONFIRMATION_WINDOW_WIDTH,
+            height: (popupOptions === null || popupOptions === void 0 ? void 0 : popupOptions.height) || CONFIRMATION_WINDOW_HEIGHT,
         });
     }
     closeWindow() {
-        this.confirmationWindow?.close();
+        var _a;
+        (_a = this.confirmationWindow) === null || _a === void 0 ? void 0 : _a.close();
     }
     logout() {
         return new Promise((resolve, rejects) => {
@@ -14713,7 +14810,8 @@ class ConfirmationScreen {
         this.confirmationWindow.location.href = href;
         // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
         const timer = setInterval(() => {
-            if (this.confirmationWindow?.closed) {
+            var _a;
+            if ((_a = this.confirmationWindow) === null || _a === void 0 ? void 0 : _a.closed) {
                 clearInterval(timer);
                 window.removeEventListener('message', messageHandler);
                 resolve({ confirmed: false });
@@ -14736,7 +14834,9 @@ var ProviderEvent;
 })(ProviderEvent || (ProviderEvent = {}));
 
 class TypedEventEmitter {
-    emitter = new EventEmitter();
+    constructor() {
+        this.emitter = new EventEmitter();
+    }
     emit(eventName, ...eventArg) {
         this.emitter.emit(eventName, ...eventArg);
     }
@@ -14762,23 +14862,26 @@ const META_TRANSACTIONS_TYPE = `tuple(
   bytes data
 )[]`;
 function getNormalisedTransactions(txs) {
-    return txs.map((t) => ({
-        delegateCall: t.delegateCall === true,
-        revertOnError: t.revertOnError === true,
-        gasLimit: t.gasLimit ?? constants.Zero,
-        target: t.to ?? constants.AddressZero,
-        value: t.value ?? constants.Zero,
-        data: t.data ?? [],
-    }));
+    return txs.map((t) => {
+        var _a, _b, _c, _d;
+        return ({
+            delegateCall: t.delegateCall === true,
+            revertOnError: t.revertOnError === true,
+            gasLimit: (_a = t.gasLimit) !== null && _a !== void 0 ? _a : constants.Zero,
+            target: (_b = t.to) !== null && _b !== void 0 ? _b : constants.AddressZero,
+            value: (_c = t.value) !== null && _c !== void 0 ? _c : constants.Zero,
+            data: (_d = t.data) !== null && _d !== void 0 ? _d : [],
+        });
+    });
 }
 function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
     const packMetaTransactionsNonceData = utils$2.defaultAbiCoder.encode(['uint256', META_TRANSACTIONS_TYPE], [nonce, normalisedTransactions]);
     return utils$2.keccak256(packMetaTransactionsNonceData);
 }
-const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
+const getNonce = (jsonRpcProvider, smartContractWalletAddress) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const contract = new Contract(smartContractWalletAddress, walletContracts.mainModule.abi, jsonRpcProvider);
-        const result = await contract.nonce();
+        const result = yield contract.nonce();
         if (result instanceof BigNumber) {
             return result;
         }
@@ -14794,9 +14897,9 @@ const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
         throw error;
     }
     throw new Error('Unexpected result from contract.nonce() call.');
-};
+});
 const encodeMessageSubDigest = (chainId, walletAddress, digest) => (utils$2.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]));
-const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
+const getSignedMetaTransactions = (metaTransactions, nonce, chainId, walletAddress, signer) => __awaiter(void 0, void 0, void 0, function* () {
     const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
     // Get the hash
     const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
@@ -14804,7 +14907,7 @@ const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walle
     const hash = utils$2.keccak256(completePayload);
     // Sign the digest
     const hashArray = utils$2.arrayify(hash);
-    const ethsigNoType = await signer.signMessage(hashArray);
+    const ethsigNoType = yield signer.signMessage(hashArray);
     const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
     // Add metadata
     const encodedSignature = v1.signature.encodeSignature({
@@ -14826,14 +14929,14 @@ const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walle
         nonce,
         encodedSignature,
     ]);
-};
+});
 const decodeRelayerTypedDataSignature = (relayerSignature) => {
     const signatureWithThreshold = `0x0000${relayerSignature}`;
     return v1.signature.decodeSignature(signatureWithThreshold);
 };
-const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAddress, signer) => {
+const getSignedTypedData = (typedData, relayerSignature, chainId, walletAddress, signer) => __awaiter(void 0, void 0, void 0, function* () {
     // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
-    const types = { ...typedData.types };
+    const types = Object.assign({}, typedData.types);
     // @ts-ignore
     delete types.EIP712Domain;
     // Hash the EIP712 payload and generate the complete payload
@@ -14844,7 +14947,7 @@ const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAd
     // Sign the sub digest
     // https://github.com/immutable/wallet-contracts/blob/7824b5f24b2e0eb2dc465ecb5cd71f3984556b73/src/contracts/modules/commons/ModuleAuth.sol#L155
     const hashArray = utils$2.arrayify(hash);
-    const ethsigNoType = await signer.signMessage(hashArray);
+    const ethsigNoType = yield signer.signMessage(hashArray);
     const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
     // Combine the relayer and user signatures; sort by address to match the imageHash order
     const { signers: relayerSigners } = decodeRelayerTypedDataSignature(relayerSignature);
@@ -14855,7 +14958,7 @@ const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAd
             unrecovered: true,
             weight: SIGNATURE_WEIGHT,
             signature: signedDigest,
-            address: await signer.getAddress(),
+            address: yield signer.getAddress(),
         },
     ];
     const sortedSigners = combinedSigners.sort((a, b) => {
@@ -14874,85 +14977,88 @@ const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAd
         threshold: EIP712_SIGNATURE_THRESHOLD,
         signers: sortedSigners,
     });
-};
+});
 const getEip155ChainId = (chainId) => `eip155:${chainId}`;
 
 class RelayerClient {
-    config;
-    jsonRpcProvider;
-    authManager;
     constructor({ config, jsonRpcProvider, authManager }) {
         this.config = config;
         this.jsonRpcProvider = jsonRpcProvider;
         this.authManager = authManager;
     }
-    async postToRelayer(request) {
-        const body = {
-            id: 1,
-            jsonrpc: '2.0',
-            ...request,
-        };
-        const user = await this.authManager.getUserZkEvm();
-        const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${user.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
+    postToRelayer(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = Object.assign({ id: 1, jsonrpc: '2.0' }, request);
+            const user = yield this.authManager.getUserZkEvm();
+            const response = yield fetch(`${this.config.relayerUrl}/v1/transactions`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${user.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            const jsonResponse = yield response.json();
+            if (jsonResponse.error) {
+                throw jsonResponse.error;
+            }
+            return jsonResponse;
         });
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) {
-            throw jsonResponse.error;
-        }
-        return jsonResponse;
-    }
-    async ethSendTransaction(to, data) {
-        const { chainId } = await this.jsonRpcProvider.ready;
-        const payload = {
-            method: 'eth_sendTransaction',
-            params: [{
-                    to,
-                    data,
-                    chainId: getEip155ChainId(chainId),
-                }],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
     }
-    async imGetTransactionByHash(hash) {
-        const payload = {
-            method: 'im_getTransactionByHash',
-            params: [hash],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
-    }
-    async imGetFeeOptions(userAddress, data) {
-        const { chainId } = await this.jsonRpcProvider.ready;
-        const payload = {
-            method: 'im_getFeeOptions',
-            params: [{
-                    userAddress,
-                    data,
-                    chainId: getEip155ChainId(chainId),
-                }],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
-    }
-    async imSignTypedData(address, eip712Payload) {
-        const { chainId } = await this.jsonRpcProvider.ready;
-        const payload = {
-            method: 'im_signTypedData',
-            params: [{
-                    address,
-                    eip712Payload,
-                    chainId: getEip155ChainId(chainId),
-                }],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
+    ethSendTransaction(to, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainId } = yield this.jsonRpcProvider.ready;
+            const payload = {
+                method: 'eth_sendTransaction',
+                params: [{
+                        to,
+                        data,
+                        chainId: getEip155ChainId(chainId),
+                    }],
+            };
+            const { result } = yield this.postToRelayer(payload);
+            return result;
+        });
+    }
+    imGetTransactionByHash(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = {
+                method: 'im_getTransactionByHash',
+                params: [hash],
+            };
+            const { result } = yield this.postToRelayer(payload);
+            return result;
+        });
+    }
+    imGetFeeOptions(userAddress, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainId } = yield this.jsonRpcProvider.ready;
+            const payload = {
+                method: 'im_getFeeOptions',
+                params: [{
+                        userAddress,
+                        data,
+                        chainId: getEip155ChainId(chainId),
+                    }],
+            };
+            const { result } = yield this.postToRelayer(payload);
+            return result;
+        });
+    }
+    imSignTypedData(address, eip712Payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainId } = yield this.jsonRpcProvider.ready;
+            const payload = {
+                method: 'im_signTypedData',
+                params: [{
+                        address,
+                        eip712Payload,
+                        chainId: getEip155ChainId(chainId),
+                    }],
+            };
+            const { result } = yield this.postToRelayer(payload);
+            return result;
+        });
     }
 }
 
@@ -14979,8 +15085,6 @@ var RpcErrorCode;
     RpcErrorCode[RpcErrorCode["TRANSACTION_REJECTED"] = -32003] = "TRANSACTION_REJECTED";
 })(RpcErrorCode || (RpcErrorCode = {}));
 class JsonRpcError extends Error {
-    message;
-    code;
     constructor(code, message) {
         super(message);
         this.message = message;
@@ -14989,34 +15093,37 @@ class JsonRpcError extends Error {
 }
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
-    const [ethereumAddress, ethereumSignature, network, chainListResponse] = await Promise.all([
-        ethSigner.getAddress(),
-        signRaw(MESSAGE_TO_SIGN, ethSigner),
-        jsonRpcProvider.ready,
-        multiRollupApiClients.chainsApi.listChains(),
-    ]);
-    const eipChainId = getEip155ChainId(network.chainId);
-    const chainName = chainListResponse.data?.result?.find((chain) => chain.id === eipChainId)?.name;
-    if (!chainName) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Chain name does not exist on for chain id ${network.chainId}`);
-    }
-    try {
-        const registrationResponse = await multiRollupApiClients.passportApi.createCounterfactualAddressV2({
-            chainName,
-            createCounterfactualAddressRequest: {
-                ethereum_address: ethereumAddress,
-                ethereum_signature: ethereumSignature,
-            },
-        }, {
-            headers: { Authorization: `Bearer ${accessToken}` },
-        });
-        authManager.forceUserRefreshInBackground();
-        return registrationResponse.data.counterfactual_address;
-    }
-    catch (error) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
-    }
+function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const [ethereumAddress, ethereumSignature, network, chainListResponse] = yield Promise.all([
+            ethSigner.getAddress(),
+            signRaw(MESSAGE_TO_SIGN, ethSigner),
+            jsonRpcProvider.ready,
+            multiRollupApiClients.chainsApi.listChains(),
+        ]);
+        const eipChainId = getEip155ChainId(network.chainId);
+        const chainName = (_c = (_b = (_a = chainListResponse.data) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.find((chain) => chain.id === eipChainId)) === null || _c === void 0 ? void 0 : _c.name;
+        if (!chainName) {
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Chain name does not exist on for chain id ${network.chainId}`);
+        }
+        try {
+            const registrationResponse = yield multiRollupApiClients.passportApi.createCounterfactualAddressV2({
+                chainName,
+                createCounterfactualAddressRequest: {
+                    ethereum_address: ethereumAddress,
+                    ethereum_signature: ethereumSignature,
+                },
+            }, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+            });
+            authManager.forceUserRefreshInBackground();
+            return registrationResponse.data.counterfactual_address;
+        }
+        catch (error) {
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
+        }
+    });
 }
 
 const transactionRejectedCrossSdkBridgeError = 'Transaction requires confirmation but this functionality is not'
@@ -15024,14 +15131,17 @@ const transactionRejectedCrossSdkBridgeError = 'Transaction requires confirmatio
 const convertBigNumberishToString = (value) => BigNumber.from(value).toString();
 const transformGuardianTransactions = (txs) => {
     try {
-        return txs.map((t) => ({
-            delegateCall: t.delegateCall === true,
-            revertOnError: t.revertOnError === true,
-            gasLimit: t.gasLimit ? convertBigNumberishToString(t.gasLimit) : '0',
-            target: t.to ?? ethers.constants.AddressZero,
-            value: t.value ? convertBigNumberishToString(t.value) : '0',
-            data: t.data ? t.data.toString() : '0x',
-        }));
+        return txs.map((t) => {
+            var _a;
+            return ({
+                delegateCall: t.delegateCall === true,
+                revertOnError: t.revertOnError === true,
+                gasLimit: t.gasLimit ? convertBigNumberishToString(t.gasLimit) : '0',
+                target: (_a = t.to) !== null && _a !== void 0 ? _a : ethers.constants.AddressZero,
+                value: t.value ? convertBigNumberishToString(t.value) : '0',
+                data: t.data ? t.data.toString() : '0x',
+            });
+        });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -15039,11 +15149,6 @@ const transformGuardianTransactions = (txs) => {
     }
 };
 class GuardianClient {
-    transactionAPI;
-    messageAPI;
-    confirmationScreen;
-    crossSdkBridgeEnabled;
-    authManager;
     constructor({ confirmationScreen, config, authManager }) {
         const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
         this.confirmationScreen = confirmationScreen;
@@ -15060,145 +15165,157 @@ class GuardianClient {
         return (task) => this.withConfirmationScreenTask(popupWindowSize)(task)();
     }
     withConfirmationScreenTask(popupWindowSize) {
-        return (task) => async () => {
+        return (task) => () => __awaiter(this, void 0, void 0, function* () {
             this.confirmationScreen.loading(popupWindowSize);
             try {
-                return await task();
+                return yield task();
             }
             catch (err) {
                 this.confirmationScreen.closeWindow();
                 throw err;
             }
-        };
+        });
     }
     withDefaultConfirmationScreenTask(task) {
         return this.withConfirmationScreenTask()(task);
     }
-    async evaluateImxTransaction({ payloadHash }) {
-        const finallyFn = () => {
-            this.confirmationScreen.closeWindow();
-        };
-        const user = await this.authManager.getUserImx();
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
-            transactionID: payloadHash,
-            chainType: 'starkex',
-        }, { headers }), { finallyFn });
-        if (!transactionRes.data.id) {
-            throw new Error("Transaction doesn't exists");
-        }
-        const evaluateImxRes = await this.transactionAPI.evaluateTransaction({
-            id: payloadHash,
-            transactionEvaluationRequest: {
-                chainType: 'starkex',
-            },
-        }, { headers });
-        const { confirmationRequired } = evaluateImxRes.data;
-        if (confirmationRequired) {
-            if (this.crossSdkBridgeEnabled) {
-                throw new Error(transactionRejectedCrossSdkBridgeError);
-            }
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
-            if (!confirmationResult.confirmed) {
-                throw new Error('Transaction rejected by user');
-            }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
-    }
-    async evaluateEVMTransaction({ chainId, nonce, metaTransactions, }) {
-        const user = await this.authManager.getUserZkEvm();
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const guardianTransactions = transformGuardianTransactions(metaTransactions);
-        try {
-            const transactionEvaluationResponseAxiosResponse = await this.transactionAPI.evaluateTransaction({
-                id: 'evm',
+    evaluateImxTransaction({ payloadHash }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finallyFn = () => {
+                this.confirmationScreen.closeWindow();
+            };
+            const user = yield this.authManager.getUserImx();
+            const headers = { Authorization: `Bearer ${user.accessToken}` };
+            const transactionRes = yield retryWithDelay(() => __awaiter(this, void 0, void 0, function* () {
+                return this.transactionAPI.getTransactionByID({
+                    transactionID: payloadHash,
+                    chainType: 'starkex',
+                }, { headers });
+            }), { finallyFn });
+            if (!transactionRes.data.id) {
+                throw new Error("Transaction doesn't exists");
+            }
+            const evaluateImxRes = yield this.transactionAPI.evaluateTransaction({
+                id: payloadHash,
                 transactionEvaluationRequest: {
-                    chainType: 'evm',
-                    chainId,
-                    transactionData: {
-                        nonce,
-                        userAddress: user.zkEvm.ethAddress,
-                        metaTransactions: guardianTransactions,
-                    },
+                    chainType: 'starkex',
                 },
             }, { headers });
-            return transactionEvaluationResponseAxiosResponse.data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
-        }
+            const { confirmationRequired } = evaluateImxRes.data;
+            if (confirmationRequired) {
+                if (this.crossSdkBridgeEnabled) {
+                    throw new Error(transactionRejectedCrossSdkBridgeError);
+                }
+                const confirmationResult = yield this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
+                if (!confirmationResult.confirmed) {
+                    throw new Error('Transaction rejected by user');
+                }
+            }
+            else {
+                this.confirmationScreen.closeWindow();
+            }
+        });
     }
-    async validateEVMTransaction({ chainId, nonce, metaTransactions, }) {
-        const transactionEvaluationResponse = await this.evaluateEVMTransaction({
-            chainId,
-            nonce,
-            metaTransactions,
+    evaluateEVMTransaction({ chainId, nonce, metaTransactions, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUserZkEvm();
+            const headers = { Authorization: `Bearer ${user.accessToken}` };
+            const guardianTransactions = transformGuardianTransactions(metaTransactions);
+            try {
+                const transactionEvaluationResponseAxiosResponse = yield this.transactionAPI.evaluateTransaction({
+                    id: 'evm',
+                    transactionEvaluationRequest: {
+                        chainType: 'evm',
+                        chainId,
+                        transactionData: {
+                            nonce,
+                            userAddress: user.zkEvm.ethAddress,
+                            metaTransactions: guardianTransactions,
+                        },
+                    },
+                }, { headers });
+                return transactionEvaluationResponseAxiosResponse.data;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
+            }
         });
-        const { confirmationRequired, transactionId } = transactionEvaluationResponse;
-        if (confirmationRequired && this.crossSdkBridgeEnabled) {
-            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
-        }
-        if (confirmationRequired && !!transactionId) {
-            const user = await this.authManager.getUserZkEvm();
-            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');
+    }
+    validateEVMTransaction({ chainId, nonce, metaTransactions, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactionEvaluationResponse = yield this.evaluateEVMTransaction({
+                chainId,
+                nonce,
+                metaTransactions,
+            });
+            const { confirmationRequired, transactionId } = transactionEvaluationResponse;
+            if (confirmationRequired && this.crossSdkBridgeEnabled) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+            }
+            if (confirmationRequired && !!transactionId) {
+                const user = yield this.authManager.getUserZkEvm();
+                const confirmationResult = yield this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
+                if (!confirmationResult.confirmed) {
+                    throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
+                }
             }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
+            else {
+                this.confirmationScreen.closeWindow();
+            }
+        });
     }
-    async evaluateMessage({ chainID, payload }) {
-        try {
-            const user = await this.authManager.getUserZkEvm();
-            if (user === null) {
-                throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
+    evaluateMessage({ chainID, payload }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const user = yield this.authManager.getUserZkEvm();
+                if (user === null) {
+                    throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
+                }
+                const messageEvalResponse = yield this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
+                return messageEvalResponse.data;
             }
-            const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
-            return messageEvalResponse.data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
-        }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
+            }
+        });
     }
-    async validateMessage({ chainID, payload }) {
-        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload });
-        if (confirmationRequired && this.crossSdkBridgeEnabled) {
-            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
-        }
-        if (confirmationRequired && !!messageId) {
-            const user = await this.authManager.getUserZkEvm();
-            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
-            if (!confirmationResult.confirmed) {
-                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
+    validateMessage({ chainID, payload }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { messageId, confirmationRequired } = yield this.evaluateMessage({ chainID, payload });
+            if (confirmationRequired && this.crossSdkBridgeEnabled) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+            }
+            if (confirmationRequired && !!messageId) {
+                const user = yield this.authManager.getUserZkEvm();
+                const confirmationResult = yield this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
+                if (!confirmationResult.confirmed) {
+                    throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
+                }
             }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
+            else {
+                this.confirmationScreen.closeWindow();
+            }
+        });
     }
 }
 
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
-const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddress, signer, relayerClient) => {
+const getMetaTransactions = (metaTransaction, nonce, chainId, walletAddress, signer, relayerClient) => __awaiter(void 0, void 0, void 0, function* () {
     // NOTE: We sign the transaction before getting the fee options because
     // accurate estimation of a transaction gas cost is only possible if the smart
     // wallet contract can actually execute it (in a simulated environment) - and
     // it can only execute signed transactions.
-    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainId, walletAddress, signer);
+    const signedTransaction = yield getSignedMetaTransactions([metaTransaction], nonce, chainId, walletAddress, signer);
     // TODO: ID-698 Add support for non-native gas payments (e.g ERC20, feeTransaction initialisation must change)
     // NOTE: "Fee Options" represent the multiple ways we could pay for the gas
     // used in this transaction. Each fee option has a "recipientAddress" we
     // should transfer the payment to, an amount and a currency. We choose one
     // option and build a transaction that sends the expected currency amount for
     // that option to the specified address.
-    const feeOptions = await relayerClient.imGetFeeOptions(walletAddress, signedTransaction);
+    const feeOptions = yield relayerClient.imGetFeeOptions(walletAddress, signedTransaction);
     const imxFeeOption = feeOptions.find((feeOption) => feeOption.tokenSymbol === 'IMX');
     if (!imxFeeOption) {
         throw new Error('Failed to retrieve fees for IMX token');
@@ -15213,16 +15330,16 @@ const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddres
         return [metaTransaction];
     }
     return [metaTransaction, feeMetaTransaction];
-};
+});
 const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
-    .withConfirmationScreen({ width: 480, height: 720 })(async () => {
+    .withConfirmationScreen({ width: 480, height: 720 })(() => __awaiter(void 0, void 0, void 0, function* () {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
     }
-    const { chainId } = await jsonRpcProvider.ready;
+    const { chainId } = yield jsonRpcProvider.ready;
     const chainIdBigNumber = BigNumber.from(chainId);
-    const nonce = await getNonce(jsonRpcProvider, zkevmAddress);
+    const nonce = yield getNonce(jsonRpcProvider, zkevmAddress);
     const metaTransaction = {
         to: transactionRequest.to,
         data: transactionRequest.data,
@@ -15230,9 +15347,9 @@ const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, gu
         value: transactionRequest.value,
         revertOnError: true,
     };
-    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, zkevmAddress, ethSigner, relayerClient);
+    const metaTransactions = yield getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, zkevmAddress, ethSigner, relayerClient);
     // Parallelize the validation and signing of the transaction
-    const [, signedTransactions] = await Promise.all([
+    const [, signedTransactions] = yield Promise.all([
         guardianClient.validateEVMTransaction({
             chainId: getEip155ChainId(chainId),
             nonce: convertBigNumberishToString(nonce),
@@ -15242,9 +15359,9 @@ const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, gu
         // whole payload is different and needs a new signature.
         getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, ethSigner),
     ]);
-    const relayerId = await relayerClient.ethSendTransaction(zkevmAddress, signedTransactions);
-    const retrieveRelayerTransaction = async () => {
-        const tx = await relayerClient.imGetTransactionByHash(relayerId);
+    const relayerId = yield relayerClient.ethSendTransaction(zkevmAddress, signedTransactions);
+    const retrieveRelayerTransaction = () => __awaiter(void 0, void 0, void 0, function* () {
+        const tx = yield relayerClient.imGetTransactionByHash(relayerId);
         // NOTE: The transaction hash is only available from the Relayer once the
         // transaction is actually submitted onchain. Hence we need to poll the
         // Relayer get transaction endpoint until the status transitions to one that
@@ -15253,8 +15370,8 @@ const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, gu
             throw new Error();
         }
         return tx;
-    };
-    const relayerTransaction = await retryWithDelay(retrieveRelayerTransaction, {
+    });
+    const relayerTransaction = yield retryWithDelay(retrieveRelayerTransaction, {
         retries: MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES,
         interval: TRANSACTION_HASH_RETRIEVAL_WAIT,
         finalErr: new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'transaction hash not generated in time'),
@@ -15270,11 +15387,12 @@ const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, gu
         throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, errorMessage);
     }
     return relayerTransaction.hash;
-});
+}));
 
 const REQUIRED_TYPED_DATA_PROPERTIES = ['types', 'domain', 'primaryType', 'message'];
 const isValidTypedDataPayload = (typedData) => (REQUIRED_TYPED_DATA_PROPERTIES.every((key) => key in typedData));
 const transformTypedData = (typedData, chainId) => {
+    var _a;
     let transformedTypedData;
     if (typeof typedData === 'string') {
         try {
@@ -15293,7 +15411,7 @@ const transformTypedData = (typedData, chainId) => {
     if (!isValidTypedDataPayload(transformedTypedData)) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid typed data argument. The following properties are required: ${REQUIRED_TYPED_DATA_PROPERTIES.join(', ')}`);
     }
-    const providedChainId = transformedTypedData.domain?.chainId;
+    const providedChainId = (_a = transformedTypedData.domain) === null || _a === void 0 ? void 0 : _a.chainId;
     if (providedChainId) {
         // domain.chainId (if defined) can be a number, string, or hex value, but the relayer & guardian only accept a number.
         if (typeof providedChainId === 'string') {
@@ -15310,168 +15428,234 @@ const transformTypedData = (typedData, chainId) => {
     }
     return transformedTypedData;
 };
-const signTypedDataV4 = async ({ params, method, ethSigner, jsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
-    .withConfirmationScreen({ width: 480, height: 720 })(async () => {
-    const fromAddress = params[0];
-    const typedDataParam = params[1];
-    if (!fromAddress || !typedDataParam) {
-        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `${method} requires an address and a typed data JSON`);
-    }
-    const { chainId } = await jsonRpcProvider.ready;
-    const typedData = transformTypedData(typedDataParam, chainId);
-    await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
-    const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
-    return getSignedTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, ethSigner);
+const signTypedDataV4 = ({ params, method, ethSigner, jsonRpcProvider, relayerClient, guardianClient, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return guardianClient
+        .withConfirmationScreen({ width: 480, height: 720 })(() => __awaiter(void 0, void 0, void 0, function* () {
+        const fromAddress = params[0];
+        const typedDataParam = params[1];
+        if (!fromAddress || !typedDataParam) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `${method} requires an address and a typed data JSON`);
+        }
+        const { chainId } = yield jsonRpcProvider.ready;
+        const typedData = transformTypedData(typedDataParam, chainId);
+        yield guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
+        const relayerSignature = yield relayerClient.imSignTypedData(fromAddress, typedData);
+        return getSignedTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, ethSigner);
+    }));
 });
 
+var _ZkEvmProvider_instances, _ZkEvmProvider_authManager, _ZkEvmProvider_config, _ZkEvmProvider_eventEmitter, _ZkEvmProvider_guardianClient, _ZkEvmProvider_jsonRpcProvider, _ZkEvmProvider_magicAdapter, _ZkEvmProvider_multiRollupApiClients, _ZkEvmProvider_relayerClient, _ZkEvmProvider_ethSigner, _ZkEvmProvider_signerInitialisationError, _ZkEvmProvider_zkEvmAddress, _ZkEvmProvider_handleLogout, _ZkEvmProvider_initialiseEthSigner, _ZkEvmProvider_getSigner, _ZkEvmProvider_performRequest, _ZkEvmProvider_performJsonRpcRequest;
 const isZkEvmUser = (user) => 'zkEvm' in user;
 class ZkEvmProvider {
-    #authManager;
-    #config;
-    #eventEmitter;
-    #guardianClient;
-    #jsonRpcProvider; // Used for read
-    #magicAdapter;
-    #multiRollupApiClients;
-    #relayerClient;
-    /**
-     * This property is set during `#initialiseEthSigner` and stores the signer in a promise.
-     * This property is not meant to be accessed directly, but through the
-     * `#getSigner` method.
-     * @see getSigner
-     */
-    #ethSigner;
-    #signerInitialisationError;
-    #zkEvmAddress;
-    isPassport = true;
     constructor({ authManager, magicAdapter, config, multiRollupApiClients, passportEventEmitter, guardianClient, }) {
-        this.#authManager = authManager;
-        this.#magicAdapter = magicAdapter;
-        this.#config = config;
-        this.#guardianClient = guardianClient;
+        _ZkEvmProvider_instances.add(this);
+        _ZkEvmProvider_authManager.set(this, void 0);
+        _ZkEvmProvider_config.set(this, void 0);
+        _ZkEvmProvider_eventEmitter.set(this, void 0);
+        _ZkEvmProvider_guardianClient.set(this, void 0);
+        _ZkEvmProvider_jsonRpcProvider.set(this, void 0); // Used for read
+        _ZkEvmProvider_magicAdapter.set(this, void 0);
+        _ZkEvmProvider_multiRollupApiClients.set(this, void 0);
+        _ZkEvmProvider_relayerClient.set(this, void 0);
+        /**
+         * This property is set during `#initialiseEthSigner` and stores the signer in a promise.
+         * This property is not meant to be accessed directly, but through the
+         * `#getSigner` method.
+         * @see getSigner
+         */
+        _ZkEvmProvider_ethSigner.set(this, void 0);
+        _ZkEvmProvider_signerInitialisationError.set(this, void 0);
+        _ZkEvmProvider_zkEvmAddress.set(this, void 0);
+        this.isPassport = true;
+        _ZkEvmProvider_handleLogout.set(this, () => {
+            const shouldEmitAccountsChanged = !!__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f");
+            __classPrivateFieldSet(this, _ZkEvmProvider_ethSigner, undefined, "f");
+            __classPrivateFieldSet(this, _ZkEvmProvider_zkEvmAddress, undefined, "f");
+            if (shouldEmitAccountsChanged) {
+                __classPrivateFieldGet(this, _ZkEvmProvider_eventEmitter, "f").emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+            }
+        });
+        __classPrivateFieldSet(this, _ZkEvmProvider_authManager, authManager, "f");
+        __classPrivateFieldSet(this, _ZkEvmProvider_magicAdapter, magicAdapter, "f");
+        __classPrivateFieldSet(this, _ZkEvmProvider_config, config, "f");
+        __classPrivateFieldSet(this, _ZkEvmProvider_guardianClient, guardianClient, "f");
         if (config.crossSdkBridgeEnabled) {
             // JsonRpcProvider by default sets the referrer as "client".
             // On Unreal 4 this errors as the browser used is expecting a valid URL.
-            this.#jsonRpcProvider = new JsonRpcProvider({
-                url: this.#config.zkEvmRpcUrl,
+            __classPrivateFieldSet(this, _ZkEvmProvider_jsonRpcProvider, new JsonRpcProvider({
+                url: __classPrivateFieldGet(this, _ZkEvmProvider_config, "f").zkEvmRpcUrl,
                 fetchOptions: { referrer: 'http://imtblgamesdk.local' },
-            });
+            }), "f");
         }
         else {
-            this.#jsonRpcProvider = new JsonRpcProvider(this.#config.zkEvmRpcUrl);
+            __classPrivateFieldSet(this, _ZkEvmProvider_jsonRpcProvider, new JsonRpcProvider(__classPrivateFieldGet(this, _ZkEvmProvider_config, "f").zkEvmRpcUrl), "f");
         }
-        this.#relayerClient = new RelayerClient({
-            config: this.#config,
-            jsonRpcProvider: this.#jsonRpcProvider,
-            authManager: this.#authManager,
+        __classPrivateFieldSet(this, _ZkEvmProvider_relayerClient, new RelayerClient({
+            config: __classPrivateFieldGet(this, _ZkEvmProvider_config, "f"),
+            jsonRpcProvider: __classPrivateFieldGet(this, _ZkEvmProvider_jsonRpcProvider, "f"),
+            authManager: __classPrivateFieldGet(this, _ZkEvmProvider_authManager, "f"),
+        }), "f");
+        __classPrivateFieldSet(this, _ZkEvmProvider_multiRollupApiClients, multiRollupApiClients, "f");
+        __classPrivateFieldSet(this, _ZkEvmProvider_eventEmitter, new TypedEventEmitter(), "f");
+        passportEventEmitter.on(PassportEvents.LOGGED_OUT, __classPrivateFieldGet(this, _ZkEvmProvider_handleLogout, "f"));
+    }
+    request(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_performRequest).call(this, request);
+            }
+            catch (error) {
+                if (error instanceof JsonRpcError) {
+                    throw error;
+                }
+                if (error instanceof Error) {
+                    throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+                }
+                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+            }
         });
-        this.#multiRollupApiClients = multiRollupApiClients;
-        this.#eventEmitter = new TypedEventEmitter();
-        passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.#handleLogout);
-    }
-    #handleLogout = () => {
-        const shouldEmitAccountsChanged = !!this.#zkEvmAddress;
-        this.#ethSigner = undefined;
-        this.#zkEvmAddress = undefined;
-        if (shouldEmitAccountsChanged) {
-            this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+    }
+    sendAsync(request, callback) {
+        if (!callback) {
+            throw new Error('No callback provided');
         }
-    };
-    /**
-     * This method is called by `eth_requestAccounts` and asynchronously initialises the signer.
-     * The signer is stored in a promise so that it can be retrieved by the provider
-     * when needed.
-     *
-     * If an error is thrown during initialisation, it is stored in the `signerInitialisationError`,
-     * so that it doesn't result in an unhandled promise rejection.
-     *
-     * This error is thrown when the signer is requested through:
-     * @see #getSigner
-     *
-     */
-    #initialiseEthSigner(user) {
-        const generateSigner = async () => {
-            const magicRpcProvider = await this.#magicAdapter.login(user.idToken);
-            const web3Provider = new Web3Provider(magicRpcProvider);
-            return web3Provider.getSigner();
-        };
-        // eslint-disable-next-line no-async-promise-executor
-        this.#ethSigner = new Promise(async (resolve) => {
-            try {
-                resolve(await generateSigner());
+        if (Array.isArray(request)) {
+            Promise.all(request.map(__classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_performJsonRpcRequest))).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, []);
+            });
+        }
+        else {
+            __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_performJsonRpcRequest).call(this, request).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, null);
+            });
+        }
+    }
+    send(request, callbackOrParams, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Web3 >= 1.0.0-beta.38 calls `send` with method and parameters.
+            if (typeof request === 'string') {
+                if (typeof callbackOrParams === 'function') {
+                    return this.sendAsync({
+                        method: request,
+                        params: [],
+                    }, callbackOrParams);
+                }
+                if (callback) {
+                    return this.sendAsync({
+                        method: request,
+                        params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+                    }, callback);
+                }
+                return this.request({
+                    method: request,
+                    params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+                });
             }
-            catch (err) {
-                // Capture and store the initialization error
-                this.#signerInitialisationError = err;
-                resolve(undefined);
+            // Web3 <= 1.0.0-beta.37 uses `send` with a callback for async queries.
+            if (typeof callbackOrParams === 'function') {
+                return this.sendAsync(request, callbackOrParams);
             }
+            if (!Array.isArray(request) && typeof request === 'object') {
+                return __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_performJsonRpcRequest).call(this, request);
+            }
+            throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
         });
     }
-    async #getSigner() {
-        const ethSigner = await this.#ethSigner;
+    on(event, listener) {
+        __classPrivateFieldGet(this, _ZkEvmProvider_eventEmitter, "f").on(event, listener);
+    }
+    removeListener(event, listener) {
+        __classPrivateFieldGet(this, _ZkEvmProvider_eventEmitter, "f").removeListener(event, listener);
+    }
+}
+_ZkEvmProvider_authManager = new WeakMap(), _ZkEvmProvider_config = new WeakMap(), _ZkEvmProvider_eventEmitter = new WeakMap(), _ZkEvmProvider_guardianClient = new WeakMap(), _ZkEvmProvider_jsonRpcProvider = new WeakMap(), _ZkEvmProvider_magicAdapter = new WeakMap(), _ZkEvmProvider_multiRollupApiClients = new WeakMap(), _ZkEvmProvider_relayerClient = new WeakMap(), _ZkEvmProvider_ethSigner = new WeakMap(), _ZkEvmProvider_signerInitialisationError = new WeakMap(), _ZkEvmProvider_zkEvmAddress = new WeakMap(), _ZkEvmProvider_handleLogout = new WeakMap(), _ZkEvmProvider_instances = new WeakSet(), _ZkEvmProvider_initialiseEthSigner = function _ZkEvmProvider_initialiseEthSigner(user) {
+    const generateSigner = () => __awaiter(this, void 0, void 0, function* () {
+        const magicRpcProvider = yield __classPrivateFieldGet(this, _ZkEvmProvider_magicAdapter, "f").login(user.idToken);
+        const web3Provider = new Web3Provider(magicRpcProvider);
+        return web3Provider.getSigner();
+    });
+    // eslint-disable-next-line no-async-promise-executor
+    __classPrivateFieldSet(this, _ZkEvmProvider_ethSigner, new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            resolve(yield generateSigner());
+        }
+        catch (err) {
+            // Capture and store the initialization error
+            __classPrivateFieldSet(this, _ZkEvmProvider_signerInitialisationError, err, "f");
+            resolve(undefined);
+        }
+    })), "f");
+}, _ZkEvmProvider_getSigner = function _ZkEvmProvider_getSigner() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ethSigner = yield __classPrivateFieldGet(this, _ZkEvmProvider_ethSigner, "f");
         // Throw the stored error if the signers failed to initialise
         if (typeof ethSigner === 'undefined') {
-            if (typeof this.#signerInitialisationError !== 'undefined') {
-                throw this.#signerInitialisationError;
+            if (typeof __classPrivateFieldGet(this, _ZkEvmProvider_signerInitialisationError, "f") !== 'undefined') {
+                throw __classPrivateFieldGet(this, _ZkEvmProvider_signerInitialisationError, "f");
             }
             throw new Error('Signer failed to initialise');
         }
         return ethSigner;
-    }
-    async #performRequest(request) {
+    });
+}, _ZkEvmProvider_performRequest = function _ZkEvmProvider_performRequest(request) {
+    return __awaiter(this, void 0, void 0, function* () {
         switch (request.method) {
             case 'eth_requestAccounts': {
-                if (this.#zkEvmAddress) {
-                    return [this.#zkEvmAddress];
+                if (__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")) {
+                    return [__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")];
                 }
-                const user = await this.#authManager.getUserOrLogin();
-                this.#initialiseEthSigner(user);
+                const user = yield __classPrivateFieldGet(this, _ZkEvmProvider_authManager, "f").getUserOrLogin();
+                __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_initialiseEthSigner).call(this, user);
                 if (!isZkEvmUser(user)) {
-                    const ethSigner = await this.#getSigner();
-                    this.#zkEvmAddress = await registerZkEvmUser({
+                    const ethSigner = yield __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_getSigner).call(this);
+                    __classPrivateFieldSet(this, _ZkEvmProvider_zkEvmAddress, yield registerZkEvmUser({
                         ethSigner,
-                        authManager: this.#authManager,
-                        multiRollupApiClients: this.#multiRollupApiClients,
+                        authManager: __classPrivateFieldGet(this, _ZkEvmProvider_authManager, "f"),
+                        multiRollupApiClients: __classPrivateFieldGet(this, _ZkEvmProvider_multiRollupApiClients, "f"),
                         accessToken: user.accessToken,
-                        jsonRpcProvider: this.#jsonRpcProvider,
-                    });
+                        jsonRpcProvider: __classPrivateFieldGet(this, _ZkEvmProvider_jsonRpcProvider, "f"),
+                    }), "f");
                 }
                 else {
-                    this.#zkEvmAddress = user.zkEvm.ethAddress;
+                    __classPrivateFieldSet(this, _ZkEvmProvider_zkEvmAddress, user.zkEvm.ethAddress, "f");
                 }
-                this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.#zkEvmAddress]);
-                return [this.#zkEvmAddress];
+                __classPrivateFieldGet(this, _ZkEvmProvider_eventEmitter, "f").emit(ProviderEvent.ACCOUNTS_CHANGED, [__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")]);
+                return [__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")];
             }
             case 'eth_sendTransaction': {
-                if (!this.#zkEvmAddress) {
+                if (!__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")) {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
                 }
-                const ethSigner = await this.#getSigner();
+                const ethSigner = yield __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_getSigner).call(this);
                 return sendTransaction({
                     params: request.params || [],
                     ethSigner,
-                    guardianClient: this.#guardianClient,
-                    jsonRpcProvider: this.#jsonRpcProvider,
-                    relayerClient: this.#relayerClient,
-                    zkevmAddress: this.#zkEvmAddress,
+                    guardianClient: __classPrivateFieldGet(this, _ZkEvmProvider_guardianClient, "f"),
+                    jsonRpcProvider: __classPrivateFieldGet(this, _ZkEvmProvider_jsonRpcProvider, "f"),
+                    relayerClient: __classPrivateFieldGet(this, _ZkEvmProvider_relayerClient, "f"),
+                    zkevmAddress: __classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f"),
                 });
             }
             case 'eth_accounts': {
-                return this.#zkEvmAddress ? [this.#zkEvmAddress] : [];
+                return __classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f") ? [__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")] : [];
             }
             case 'eth_signTypedData':
             case 'eth_signTypedData_v4': {
-                if (!this.#zkEvmAddress) {
+                if (!__classPrivateFieldGet(this, _ZkEvmProvider_zkEvmAddress, "f")) {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
                 }
-                const ethSigner = await this.#getSigner();
+                const ethSigner = yield __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_getSigner).call(this);
                 return signTypedDataV4({
                     method: request.method,
                     params: request.params || [],
                     ethSigner,
-                    jsonRpcProvider: this.#jsonRpcProvider,
-                    relayerClient: this.#relayerClient,
-                    guardianClient: this.#guardianClient,
+                    jsonRpcProvider: __classPrivateFieldGet(this, _ZkEvmProvider_jsonRpcProvider, "f"),
+                    relayerClient: __classPrivateFieldGet(this, _ZkEvmProvider_relayerClient, "f"),
+                    guardianClient: __classPrivateFieldGet(this, _ZkEvmProvider_guardianClient, "f"),
                 });
             }
             // Pass through methods
@@ -15488,17 +15672,18 @@ class ZkEvmProvider {
             case 'eth_getTransactionByHash':
             case 'eth_getTransactionReceipt':
             case 'eth_getTransactionCount': {
-                return this.#jsonRpcProvider.send(request.method, request.params || []);
+                return __classPrivateFieldGet(this, _ZkEvmProvider_jsonRpcProvider, "f").send(request.method, request.params || []);
             }
             default: {
                 throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
             }
         }
-    }
-    async #performJsonRpcRequest(request) {
+    });
+}, _ZkEvmProvider_performJsonRpcRequest = function _ZkEvmProvider_performJsonRpcRequest(request) {
+    return __awaiter(this, void 0, void 0, function* () {
         const { id, jsonrpc } = request;
         try {
-            const result = await this.#performRequest(request);
+            const result = yield __classPrivateFieldGet(this, _ZkEvmProvider_instances, "m", _ZkEvmProvider_performRequest).call(this, request);
             return {
                 id,
                 jsonrpc,
@@ -15522,76 +15707,8 @@ class ZkEvmProvider {
                 error: jsonRpcError,
             };
         }
-    }
-    async request(request) {
-        try {
-            return this.#performRequest(request);
-        }
-        catch (error) {
-            if (error instanceof JsonRpcError) {
-                throw error;
-            }
-            if (error instanceof Error) {
-                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
-            }
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
-        }
-    }
-    sendAsync(request, callback) {
-        if (!callback) {
-            throw new Error('No callback provided');
-        }
-        if (Array.isArray(request)) {
-            Promise.all(request.map(this.#performJsonRpcRequest)).then((result) => {
-                callback(null, result);
-            }).catch((error) => {
-                callback(error, []);
-            });
-        }
-        else {
-            this.#performJsonRpcRequest(request).then((result) => {
-                callback(null, result);
-            }).catch((error) => {
-                callback(error, null);
-            });
-        }
-    }
-    async send(request, callbackOrParams, callback) {
-        // Web3 >= 1.0.0-beta.38 calls `send` with method and parameters.
-        if (typeof request === 'string') {
-            if (typeof callbackOrParams === 'function') {
-                return this.sendAsync({
-                    method: request,
-                    params: [],
-                }, callbackOrParams);
-            }
-            if (callback) {
-                return this.sendAsync({
-                    method: request,
-                    params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
-                }, callback);
-            }
-            return this.request({
-                method: request,
-                params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
-            });
-        }
-        // Web3 <= 1.0.0-beta.37 uses `send` with a callback for async queries.
-        if (typeof callbackOrParams === 'function') {
-            return this.sendAsync(request, callbackOrParams);
-        }
-        if (!Array.isArray(request) && typeof request === 'object') {
-            return this.#performJsonRpcRequest(request);
-        }
-        throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
-    }
-    on(event, listener) {
-        this.#eventEmitter.on(event, listener);
-    }
-    removeListener(event, listener) {
-        this.#eventEmitter.removeListener(event, listener);
-    }
-}
+    });
+};
 
 const buildImxClientConfig = (passportModuleConfiguration) => {
     if (passportModuleConfiguration.overrides) {
@@ -15603,7 +15720,8 @@ const buildImxClientConfig = (passportModuleConfiguration) => {
     return imxApiConfig.getProduction();
 };
 const buildImxApiClients = (passportModuleConfiguration) => {
-    if (passportModuleConfiguration.overrides?.imxApiClients)
+    var _a;
+    if ((_a = passportModuleConfiguration.overrides) === null || _a === void 0 ? void 0 : _a.imxApiClients)
         return passportModuleConfiguration.overrides.imxApiClients;
     const config = buildImxClientConfig(passportModuleConfiguration);
     return new ImxApiClients(config);
@@ -15645,15 +15763,6 @@ const buildPrivateVars = (passportModuleConfiguration) => {
     };
 };
 class Passport {
-    authManager;
-    config;
-    confirmationScreen;
-    immutableXClient;
-    magicAdapter;
-    multiRollupApiClients;
-    passportImxProviderFactory;
-    passportEventEmitter;
-    guardianClient;
     constructor(passportModuleConfiguration) {
         const privateVars = buildPrivateVars(passportModuleConfiguration);
         this.config = privateVars.config;
@@ -15672,11 +15781,15 @@ class Passport {
      * @deprecated The method `login` with an argument of `{ useCachedSession: true }` should be used in conjunction with
      * `connectImx` instead.
      */
-    async connectImxSilent() {
-        return this.passportImxProviderFactory.getProviderSilent();
+    connectImxSilent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.passportImxProviderFactory.getProviderSilent();
+        });
     }
-    async connectImx() {
-        return this.passportImxProviderFactory.getProvider();
+    connectImx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.passportImxProviderFactory.getProvider();
+        });
     }
     connectEvm() {
         return new ZkEvmProvider({
@@ -15697,57 +15810,69 @@ class Passport {
      * @param options.anonymousId - If provided, Passport internal metrics will be enriched with this value.
      * @returns {Promise<UserProfile | null>} the user profile if the user is logged in, otherwise null
      */
-    async login(options) {
-        const { useCachedSession = false } = options || {};
-        let user = null;
-        try {
-            user = await this.authManager.getUser();
-        }
-        catch (error) {
-            if (useCachedSession) {
-                throw error;
+    login(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useCachedSession = false } = options || {};
+            let user = null;
+            try {
+                user = yield this.authManager.getUser();
             }
-            logger.warn('Failed to retrieve a cached user session', error);
-        }
-        if (!user && !useCachedSession) {
-            user = await this.authManager.login(options?.anonymousId);
-        }
-        if (user) {
-            identify({
-                passportId: user.profile.sub,
-            });
-        }
-        return user ? user.profile : null;
+            catch (error) {
+                if (useCachedSession) {
+                    throw error;
+                }
+                logger.warn('Failed to retrieve a cached user session', error);
+            }
+            if (!user && !useCachedSession) {
+                user = yield this.authManager.login(options === null || options === void 0 ? void 0 : options.anonymousId);
+            }
+            if (user) {
+                identify({
+                    passportId: user.profile.sub,
+                });
+            }
+            return user ? user.profile : null;
+        });
     }
-    async loginCallback() {
-        return this.authManager.loginCallback();
+    loginCallback() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.authManager.loginCallback();
+        });
     }
-    async loginWithDeviceFlow(options) {
-        return this.authManager.loginWithDeviceFlow(options?.anonymousId);
+    loginWithDeviceFlow(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.authManager.loginWithDeviceFlow(options === null || options === void 0 ? void 0 : options.anonymousId);
+        });
     }
-    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
-        const user = await this.authManager.loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs);
-        return user.profile;
+    loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs);
+            return user.profile;
+        });
     }
     loginWithPKCEFlow() {
         return this.authManager.getPKCEAuthorizationUrl();
     }
-    async loginWithPKCEFlowCallback(authorizationCode, state) {
-        const user = await this.authManager.loginWithPKCEFlowCallback(authorizationCode, state);
-        return user.profile;
+    loginWithPKCEFlowCallback(authorizationCode, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.loginWithPKCEFlowCallback(authorizationCode, state);
+            return user.profile;
+        });
     }
-    async logout() {
-        try {
-            await this.confirmationScreen.logout();
-        }
-        catch (err) {
-            logger.warn('Failed to logout from confirmation screen', err);
-        }
-        await Promise.allSettled([
-            this.authManager.logout(),
-            this.magicAdapter.logout(),
-        ]);
-        this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.confirmationScreen.logout();
+            }
+            catch (err) {
+                logger.warn('Failed to logout from confirmation screen', err);
+            }
+            yield Promise.allSettled([
+                this.authManager.logout(),
+                this.magicAdapter.logout(),
+            ]);
+            this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
+        });
     }
     /**
      * Logs the user out of Passport when using device flow authentication.
@@ -15755,42 +15880,54 @@ class Passport {
      * @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();
+    logoutDeviceFlow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authManager.removeUser();
+            yield 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'.
      */
-    async logoutSilentCallback(url) {
-        return this.authManager.logoutSilentCallback(url);
+    logoutSilentCallback(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.authManager.logoutSilentCallback(url);
+        });
     }
-    async getUserInfo() {
-        const user = await this.authManager.getUser();
-        return user?.profile;
+    getUserInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUser();
+            return user === null || user === void 0 ? void 0 : user.profile;
+        });
     }
-    async getIdToken() {
-        const user = await this.authManager.getUser();
-        return user?.idToken;
+    getIdToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUser();
+            return user === null || user === void 0 ? void 0 : user.idToken;
+        });
     }
-    async getAccessToken() {
-        const user = await this.authManager.getUser();
-        return user?.accessToken;
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUser();
+            return user === null || user === void 0 ? void 0 : user.accessToken;
+        });
     }
-    async getLinkedAddresses() {
-        const user = await this.authManager.getUser();
-        if (!user?.profile.sub) {
-            return [];
-        }
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const linkedAddressesResult = await this.multiRollupApiClients.passportApi.getLinkedAddresses({
-            chainName: ChainName.ETHEREUM,
-            userId: user?.profile.sub,
-        }, { headers });
-        return linkedAddressesResult.data.linked_addresses;
+    getLinkedAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authManager.getUser();
+            if (!(user === null || user === void 0 ? void 0 : user.profile.sub)) {
+                return [];
+            }
+            const headers = { Authorization: `Bearer ${user.accessToken}` };
+            const linkedAddressesResult = yield this.multiRollupApiClients.passportApi.getLinkedAddresses({
+                chainName: ChainName.ETHEREUM,
+                userId: user === null || user === void 0 ? void 0 : user.profile.sub,
+            }, { headers });
+            return linkedAddressesResult.data.linked_addresses;
+        });
     }
 }