@imtbl/sdk 0.1.9-alpha.3 → 0.1.9

package/dist/passport.js

@@ -21,7 +21,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.1.9-alpha.3',
+    sdkVersion: 'ts-immutable-sdk-0.0.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -524,69 +524,6 @@ class ImmutableXClient {
     }
 }
 
-// used to sign message with L1 keys. Used for registration
-function serializeEthSignature(sig) {
-    // This is because golang appends a recovery param
-    // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
-        + encUtils.padLeft(sig.s.toString(16), 64)
-        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
-}
-function importRecoveryParam(v) {
-    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
-        ? new BN(v, 16).sub(new BN(27)).toNumber()
-        : new BN(v, 16).toNumber();
-    return v.trim()
-        ? isValidBigNumber
-        : undefined;
-}
-// used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
-function deserializeSignature(sig, size = 64) {
-    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
-    return {
-        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
-        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
-        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
-    };
-}
-async function signRaw(payload, signer) {
-    const signature = deserializeSignature(await signer.signMessage(payload));
-    return serializeEthSignature(signature);
-}
-
-/**
- * Helper method to convert token type to a SignableToken type
- * @param token - the token type to convert to a SignableToken type
- * @returns the converted SignableToken
- */
-function convertToSignableToken(token) {
-    switch (token.type) {
-        case 'ERC721':
-            return {
-                type: 'ERC721',
-                data: {
-                    token_id: token.tokenId,
-                    token_address: token.tokenAddress,
-                },
-            };
-        case 'ERC20':
-            return {
-                type: 'ERC20',
-                data: {
-                    token_address: token.tokenAddress,
-                },
-            };
-        case 'ETH':
-        default:
-            return {
-                type: 'ETH',
-                data: {
-                    decimals: 18,
-                },
-            };
-    }
-}
-
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -3798,7 +3735,7 @@ var globalAxios = axios;
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Swagger Guardian
+ * Guardian
  * Guardian API
  *
  * The version of the OpenAPI document: 1.0.0
@@ -3808,7 +3745,7 @@ var globalAxios = axios;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-const BASE_PATH = "http://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
+const BASE_PATH = "https://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
 /**
  *
  * @export
@@ -3845,7 +3782,7 @@ class RequiredError extends Error {
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Swagger Guardian
+ * Guardian
  * Guardian API
  *
  * The version of the OpenAPI document: 1.0.0
@@ -3911,6 +3848,19 @@ const setSearchParams = function (url, ...objects) {
     setFlattenedQueryParams(searchParams, objects);
     url.search = searchParams.toString();
 };
+/**
+ *
+ * @export
+ */
+const serializeDataIfNeeded = function (value, requestOptions, configuration) {
+    const nonString = typeof value !== 'string';
+    const needsSerialization = nonString && configuration && configuration.isJsonMime
+        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
+        : nonString;
+    return needsSerialization
+        ? JSON.stringify(value !== undefined ? value : {})
+        : (value || "");
+};
 /**
  *
  * @export
@@ -3932,7 +3882,7 @@ const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, confi
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Swagger Guardian
+ * Guardian
  * Guardian API
  *
  * The version of the OpenAPI document: 1.0.0
@@ -3943,22 +3893,25 @@ const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, confi
  * Do not edit the class manually.
  */
 /**
- * StarkexTransactionsApi - axios parameter creator
+ * TransactionsApi - axios parameter creator
  * @export
  */
-const StarkexTransactionsApiAxiosParamCreator = function (configuration) {
+const TransactionsApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Check if it is a valid transaction by payload hash
-         * @summary Evaluate if it is an valid transaction
+         * Approve a pending transaction
+         * @summary Approve a pending transaction given chain
          * @param {string} payloadHash Hash for the payload
+         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transactio
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        evaluateStarkexTransaction: async (payloadHash, options = {}) => {
+        approvePendingTransaction: async (payloadHash, transactionApprovalRequest, options = {}) => {
             // verify required parameter 'payloadHash' is not null or undefined
-            assertParamExists('evaluateStarkexTransaction', 'payloadHash', payloadHash);
-            const localVarPath = `/guardian/v1/starkex/evaluate/{payloadHash}`
+            assertParamExists('approvePendingTransaction', 'payloadHash', payloadHash);
+            // verify required parameter 'transactionApprovalRequest' is not null or undefined
+            assertParamExists('approvePendingTransaction', 'transactionApprovalRequest', transactionApprovalRequest);
+            const localVarPath = `/guardian/v1/transactions/{payloadHash}/approve`
                 .replace(`{${"payloadHash"}}`, encodeURIComponent(String(payloadHash)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -3972,80 +3925,58 @@ const StarkexTransactionsApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(transactionApprovalRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
-    };
-};
-/**
- * StarkexTransactionsApi - functional programming interface
- * @export
- */
-const StarkexTransactionsApiFp = function (configuration) {
-    const localVarAxiosParamCreator = StarkexTransactionsApiAxiosParamCreator(configuration);
-    return {
         /**
-         * Check if it is a valid transaction by payload hash
-         * @summary Evaluate if it is an valid transaction
-         * @param {string} payloadHash Hash for the payload
+         * Check if the transaction is valid by transaction ID for both StarkEx and EVM
+         * @summary Evaluate a transaction
+         * @param {string} id Transaction identifier: payloadHash on StarkEx or EVM ID
+         * @param {TransactionEvaluationRequest} transactionEvaluationRequest Specifies the kind of transaction
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async evaluateStarkexTransaction(payloadHash, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateStarkexTransaction(payloadHash, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        evaluateTransaction: async (id, transactionEvaluationRequest, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('evaluateTransaction', 'id', id);
+            // verify required parameter 'transactionEvaluationRequest' is not null or undefined
+            assertParamExists('evaluateTransaction', 'transactionEvaluationRequest', transactionEvaluationRequest);
+            const localVarPath = `/guardian/v1/transactions/{id}/evaluate`
+                .replace(`{${"id"}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(transactionEvaluationRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
-    };
-};
-/**
- * StarkexTransactionsApi - object-oriented interface
- * @export
- * @class StarkexTransactionsApi
- * @extends {BaseAPI}
- */
-class StarkexTransactionsApi extends BaseAPI {
-    /**
-     * Check if it is a valid transaction by payload hash
-     * @summary Evaluate if it is an valid transaction
-     * @param {StarkexTransactionsApiEvaluateStarkexTransactionRequest} requestParameters Request parameters.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof StarkexTransactionsApi
-     */
-    evaluateStarkexTransaction(requestParameters, options) {
-        return StarkexTransactionsApiFp(this.configuration).evaluateStarkexTransaction(requestParameters.payloadHash, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-
-/* tslint:disable */
-/* eslint-disable */
-/**
- * Swagger Guardian
- * Guardian API
- *
- * The version of the OpenAPI document: 1.0.0
- * Contact: support@immutable.com
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-/**
- * TransactionsApi - axios parameter creator
- * @export
- */
-const TransactionsApiAxiosParamCreator = function (configuration) {
-    return {
         /**
          * Get a transaction by payload hash
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
-         * @param {string} chainType roll up type
+         * @param {'starkex' | 'evm'} chainType roll up type
          * @param {number} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -4092,11 +4023,35 @@ const TransactionsApiAxiosParamCreator = function (configuration) {
 const TransactionsApiFp = function (configuration) {
     const localVarAxiosParamCreator = TransactionsApiAxiosParamCreator(configuration);
     return {
+        /**
+         * Approve a pending transaction
+         * @summary Approve a pending transaction given chain
+         * @param {string} payloadHash Hash for the payload
+         * @param {TransactionApprovalRequest} transactionApprovalRequest request body for approving a pending transactio
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async approvePendingTransaction(payloadHash, transactionApprovalRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.approvePendingTransaction(payloadHash, transactionApprovalRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Check if the transaction is valid by transaction ID for both StarkEx and EVM
+         * @summary Evaluate a transaction
+         * @param {string} id Transaction identifier: payloadHash on StarkEx or EVM ID
+         * @param {TransactionEvaluationRequest} transactionEvaluationRequest Specifies the kind of transaction
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async evaluateTransaction(id, transactionEvaluationRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateTransaction(id, transactionEvaluationRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Get a transaction by payload hash
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
-         * @param {string} chainType roll up type
+         * @param {'starkex' | 'evm'} chainType roll up type
          * @param {number} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -4114,6 +4069,28 @@ const TransactionsApiFp = function (configuration) {
  * @extends {BaseAPI}
  */
 class TransactionsApi extends BaseAPI {
+    /**
+     * Approve a pending transaction
+     * @summary Approve a pending transaction given chain
+     * @param {TransactionsApiApprovePendingTransactionRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionsApi
+     */
+    approvePendingTransaction(requestParameters, options) {
+        return TransactionsApiFp(this.configuration).approvePendingTransaction(requestParameters.payloadHash, requestParameters.transactionApprovalRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Check if the transaction is valid by transaction ID for both StarkEx and EVM
+     * @summary Evaluate a transaction
+     * @param {TransactionsApiEvaluateTransactionRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionsApi
+     */
+    evaluateTransaction(requestParameters, options) {
+        return TransactionsApiFp(this.configuration).evaluateTransaction(requestParameters.id, requestParameters.transactionEvaluationRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Get a transaction by payload hash
      * @summary Info for a specific transaction
@@ -4130,7 +4107,7 @@ class TransactionsApi extends BaseAPI {
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Swagger Guardian
+ * Guardian
  * Guardian API
  *
  * The version of the OpenAPI document: 1.0.0
@@ -4215,6 +4192,69 @@ class Configuration {
     }
 }
 
+// used to sign message with L1 keys. Used for registration
+function serializeEthSignature(sig) {
+    // This is because golang appends a recovery param
+    // https://github.com/ethers-io/ethers.js/issues/823
+    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
+        + encUtils.padLeft(sig.s.toString(16), 64)
+        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+}
+function importRecoveryParam(v) {
+    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
+        ? new BN(v, 16).sub(new BN(27)).toNumber()
+        : new BN(v, 16).toNumber();
+    return v.trim()
+        ? isValidBigNumber
+        : undefined;
+}
+// used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
+function deserializeSignature(sig, size = 64) {
+    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
+    return {
+        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
+        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
+    };
+}
+async function signRaw(payload, signer) {
+    const signature = deserializeSignature(await signer.signMessage(payload));
+    return serializeEthSignature(signature);
+}
+
+/**
+ * Helper method to convert token type to a SignableToken type
+ * @param token - the token type to convert to a SignableToken type
+ * @returns the converted SignableToken
+ */
+function convertToSignableToken(token) {
+    switch (token.type) {
+        case 'ERC721':
+            return {
+                type: 'ERC721',
+                data: {
+                    token_id: token.tokenId,
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ERC20':
+            return {
+                type: 'ERC20',
+                data: {
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ETH':
+        default:
+            return {
+                type: 'ETH',
+                data: {
+                    decimals: 18,
+                },
+            };
+    }
+}
+
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -4373,209 +4413,130 @@ const getStarkSigner = async (signer) => withPassportError(async () => {
     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);
-}
-
-var ReceiveMessage;
-(function (ReceiveMessage) {
-    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
-    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
-    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
-})(ReceiveMessage || (ReceiveMessage = {}));
-var SendMessage;
-(function (SendMessage) {
-    SendMessage["TRANSACTION_START"] = "transaction_start";
-})(SendMessage || (SendMessage = {}));
-var TransactionTypes;
-(function (TransactionTypes) {
-    TransactionTypes["cancelOrder"] = "delete:v1/orders";
-    TransactionTypes["createOrder"] = "post:v1/orders";
-    TransactionTypes["createTrade"] = "post:v1/trades";
-    TransactionTypes["createTransfer"] = "post:v1/transfers";
-    TransactionTypes["createBatchTransfer"] = "post:v2/transfers";
-})(TransactionTypes || (TransactionTypes = {}));
-const PASSPORT_EVENT_TYPE = 'imx_passport_confirmation';
-
-const openPopupCenter = ({ url, title, width, height, }) => {
-    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
-    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
-    const newWindow = window.open(url, title, `
-      scrollbars=yes,
-      width=${width}, 
-      height=${height}, 
-      top=${top}, 
-      left=${left}
-     `);
-    if (!newWindow) {
-        throw new Error('Failed to open confirmation screen');
+const POLL_INTERVAL = 1 * 1000; // every 1 second
+const MAX_RETRIES = 3;
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const retryWithDelay = async (fn, options) => {
+    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), finallyFn = () => { }, } = options || {};
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries <= 0) {
+            return Promise.reject(finalErr);
+        }
+        await wait(interval);
+        return retryWithDelay(fn, { retries: retries - 1, finalErr, finallyFn });
+    }
+    finally {
+        if (retries <= 0) {
+            finallyFn();
+        }
     }
-    newWindow.focus();
-    return newWindow;
 };
 
-const CONFIRMATION_WINDOW_TITLE = 'Confirm this transaction';
-const CONFIRMATION_WINDOW_HEIGHT = 380;
-const CONFIRMATION_WINDOW_WIDTH = 480;
-const CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION = 1000;
-class ConfirmationScreen {
-    config;
-    confirmationWindow;
-    constructor(config) {
-        this.config = config;
-    }
-    postMessage(destinationWindow, accessToken, message) {
-        destinationWindow.postMessage({
-            eventType: PASSPORT_EVENT_TYPE,
+class GuardianClient {
+    transactionAPI;
+    confirmationScreen;
+    imxEtherAddress;
+    constructor({ imxPublicApiDomain, accessToken, confirmationScreen, imxEtherAddress, }) {
+        this.confirmationScreen = confirmationScreen;
+        this.transactionAPI = new TransactionsApi(new Configuration({
             accessToken,
-            ...message,
-        }, this.config.passportDomain);
+            basePath: imxPublicApiDomain,
+        }));
+        this.imxEtherAddress = imxEtherAddress;
     }
-    startTransaction(accessToken, transaction, popupOptions) {
-        return new Promise((resolve, reject) => {
-            const messageHandler = ({ data, origin }) => {
-                if (origin !== this.config.passportDomain
-                    || data.eventType !== PASSPORT_EVENT_TYPE) {
-                    return;
-                }
-                switch (data.messageType) {
-                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
-                        // TODO: remove once fixed
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        this.postMessage(confirmationWindow, accessToken, {
-                            messageType: SendMessage.TRANSACTION_START,
-                            messageData: transaction,
-                        });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
-                        resolve({ confirmed: true });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_ERROR: {
-                        reject(new Error('Transaction error'));
-                        break;
-                    }
-                    default:
-                        reject(new Error('Unsupported message type'));
-                }
-            };
-            window.addEventListener('message', messageHandler);
-            const confirmationWindow = openPopupCenter({
-                url: `${this.config.passportDomain}/transaction-confirmation`,
-                title: CONFIRMATION_WINDOW_TITLE,
-                width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
-                height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
-            });
-            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(() => {
-                if (confirmationWindow.closed) {
-                    clearInterval(timer);
-                    window.removeEventListener('message', messageHandler);
-                    resolve({ confirmed: false });
-                }
-            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
-        });
+    loading(popupWindowSize) {
+        this.confirmationScreen.loading(popupWindowSize);
     }
-    startGuardianTransaction(transactionId) {
-        return new Promise((resolve, reject) => {
-            const messageHandler = ({ data, origin }) => {
-                if (origin !== this.config.passportDomain
-                    || data.eventType !== PASSPORT_EVENT_TYPE) {
-                    return;
-                }
-                switch (data.messageType) {
-                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
-                        resolve({ confirmed: true });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_ERROR: {
-                        reject(new Error('Transaction error'));
-                        break;
-                    }
-                    default:
-                        reject(new Error('Unsupported message type'));
-                }
-            };
-            window.addEventListener('message', messageHandler);
-            if (!this.confirmationWindow) {
-                resolve({ confirmed: false });
-                return;
-            }
-            // eslint-disable-next-line max-len
-            this.confirmationWindow.location.href = `${this.config.passportDomain}/transaction-confirmation/transaction.html?transactionId=${transactionId}&chainType=starkex`;
-            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(() => {
-                if (this.confirmationWindow?.closed) {
-                    clearInterval(timer);
-                    window.removeEventListener('message', messageHandler);
-                    resolve({ confirmed: false });
-                }
-            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+    async validate({ payloadHash }) {
+        const finallyFn = () => {
+            this.confirmationScreen.closeWindow();
+        };
+        const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
+            transactionID: payloadHash,
+            chainType: 'starkex',
+        }), { finallyFn });
+        if (!transactionRes.data.id) {
+            throw new Error("Transaction doesn't exists");
+        }
+        const evaluateStarkexRes = await this.transactionAPI.evaluateTransaction({
+            id: payloadHash,
+            transactionEvaluationRequest: {
+                chainType: 'starkex',
+            },
         });
+        const { confirmationRequired } = evaluateStarkexRes.data;
+        if (confirmationRequired) {
+            const confirmationResult = await this.confirmationScreen.startGuardianTransaction(payloadHash, this.imxEtherAddress);
+            if (!confirmationResult.confirmed) {
+                throw new Error('Transaction rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
     }
-    loading(popupOptions) {
-        this.confirmationWindow = openPopupCenter({
-            url: `${this.config.passportDomain}/transaction-confirmation/loading.html`,
-            title: CONFIRMATION_WINDOW_TITLE,
-            width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
-            height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+}
+
+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,
+            },
         });
-    }
-    closeWindow() {
-        this.confirmationWindow?.close();
-    }
+        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 ERC721$1 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, confirmationScreen, }) {
+async function createOrder({ starkSigner, user, request, ordersApi, guardianClient, }) {
     return withPassportError(async () => {
+        guardianClient.loading();
         const { ethAddress } = user.imx;
         const amountSell = request.sell.type === ERC721$1 ? '1' : request.sell.amount;
         const amountBuy = request.buy.type === ERC721$1 ? '1' : request.buy.amount;
+        const headers = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
+        };
         const getSignableOrderRequestV3 = {
             user: ethAddress,
             amount_buy: amountBuy,
@@ -4587,14 +4548,10 @@ async function createOrder({ starkSigner, user, request, ordersApi, confirmation
         };
         const getSignableOrderResponse = await ordersApi.getSignableOrder({
             getSignableOrderRequestV3,
+        }, { headers });
+        await guardianClient.validate({
+            payloadHash: getSignableOrderResponse.data.payload_hash,
         });
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.createOrder,
-            transactionData: getSignableOrderRequestV3,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
         const { payload_hash: payloadHash } = getSignableOrderResponse.data;
         const starkSignature = await starkSigner.signMessage(payloadHash);
         const signableResultData = getSignableOrderResponse.data;
@@ -4614,11 +4571,7 @@ async function createOrder({ starkSigner, user, request, ordersApi, confirmation
                 vault_id_sell: signableResultData.vault_id_sell,
             },
         };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
-        const createOrderResponse = await ordersApi.createOrder(orderParams, {
+        const createOrderResponse = await ordersApi.createOrderV3(orderParams, {
             headers,
         });
         return {
@@ -4626,28 +4579,25 @@ async function createOrder({ starkSigner, user, request, ordersApi, confirmation
         };
     }, PassportErrorType.CREATE_ORDER_ERROR);
 }
-async function cancelOrder({ user, starkSigner, request, ordersApi, confirmationScreen, }) {
+async function cancelOrder({ user, starkSigner, request, ordersApi, guardianClient, }) {
     return withPassportError(async () => {
+        guardianClient.loading();
         const getSignableCancelOrderRequest = {
             order_id: request.order_id,
         };
-        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
-            getSignableCancelOrderRequest,
-        });
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.cancelOrder,
-            transactionData: getSignableCancelOrderRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
         const headers = {
             // eslint-disable-next-line @typescript-eslint/naming-convention
             Authorization: `Bearer ${user.accessToken}`,
         };
-        const cancelOrderResponse = await ordersApi.cancelOrder({
+        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
+            getSignableCancelOrderRequest,
+        }, { headers });
+        await guardianClient.validate({
+            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: {
                 order_id: request.order_id,
@@ -4687,8 +4637,9 @@ async function registerPassport({ ethSigner, starkSigner, usersApi }, authorizat
     }, PassportErrorType.USER_REGISTRATION_ERROR);
 }
 
-async function createTrade({ request, tradesApi, user, starkSigner, confirmationScreen, }) {
+async function createTrade({ request, tradesApi, user, starkSigner, guardianClient, }) {
     return withPassportError(async () => {
+        guardianClient.loading();
         const { ethAddress } = user.imx;
         const getSignableTradeRequest = {
             expiration_timestamp: request.expiration_timestamp,
@@ -4696,16 +4647,14 @@ async function createTrade({ request, tradesApi, user, starkSigner, confirmation
             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.validate({
+            payloadHash: getSignableTradeResponse.data.payload_hash,
         });
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.createTrade,
-            transactionData: getSignableTradeRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
         const { payload_hash: payloadHash } = getSignableTradeResponse.data;
         const starkSignature = await starkSigner.signMessage(payloadHash);
         const { data: signableResultData } = getSignableTradeResponse;
@@ -4727,8 +4676,6 @@ async function createTrade({ request, tradesApi, user, starkSigner, confirmation
                 vault_id_sell: signableResultData.vault_id_sell,
             },
         };
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
             headers,
         });
@@ -4736,67 +4683,10 @@ async function createTrade({ request, tradesApi, user, starkSigner, confirmation
     }, PassportErrorType.CREATE_TRADE_ERROR);
 }
 
-const POLL_INTERVAL = 1 * 1000; // every 1 second
-const MAX_RETRIES = 3;
-const wait = (ms) => new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-});
-const retryWithDelay = async (fn, options) => {
-    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), finallyFn = () => { }, } = options || {};
-    try {
-        return await fn();
-    }
-    catch (err) {
-        if (retries <= 0) {
-            return Promise.reject(finalErr);
-        }
-        await wait(interval);
-        return retryWithDelay(fn, { retries: retries - 1, finalErr, finallyFn });
-    }
-    finally {
-        if (retries <= 0) {
-            finallyFn();
-        }
-    }
-};
-
 const ERC721 = 'ERC721';
-const transferWithGuardian = async ({ accessToken, imxPublicApiDomain, payloadHash, confirmationScreen, }) => {
-    confirmationScreen.loading();
-    const transactionAPI = new TransactionsApi(new Configuration({
-        accessToken,
-        basePath: imxPublicApiDomain,
-    }));
-    const starkExTransactionApi = new StarkexTransactionsApi(new Configuration({
-        accessToken,
-        basePath: imxPublicApiDomain,
-    }));
-    const finallyFn = () => {
-        confirmationScreen.closeWindow();
-    };
-    const transactionRes = await retryWithDelay(async () => transactionAPI.getTransactionByID({
-        transactionID: payloadHash,
-        chainType: 'starkex',
-    }), { finallyFn });
-    if (!transactionRes.data.id) {
-        throw new Error("Transaction doesn't exists");
-    }
-    const evaluateStarkexRes = await starkExTransactionApi.evaluateStarkexTransaction({
-        payloadHash,
-    });
-    const { confirmationRequired } = evaluateStarkexRes.data;
-    if (confirmationRequired) {
-        const confirmationResult = await confirmationScreen.startGuardianTransaction(payloadHash);
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-    }
-    else {
-        confirmationScreen.closeWindow();
-    }
-};
-async function transfer({ request, transfersApi, starkSigner, user, imxPublicApiDomain, confirmationScreen, }) {
+async function transfer({ request, transfersApi, starkSigner, user, guardianClient, }) {
     return withPassportError(async () => {
+        guardianClient.loading();
         const transferAmount = request.type === ERC721 ? '1' : request.amount;
         const getSignableTransferRequest = {
             sender: user.imx.ethAddress,
@@ -4810,11 +4700,8 @@ async function transfer({ request, transfersApi, starkSigner, user, imxPublicApi
         const signableResult = await transfersApi.getSignableTransferV1({
             getSignableTransferRequest,
         }, { headers });
-        await transferWithGuardian({
-            imxPublicApiDomain,
-            accessToken: user.accessToken,
+        await guardianClient.validate({
             payloadHash: signableResult.data.payload_hash,
-            confirmationScreen,
         });
         const signableResultData = signableResult.data;
         const { payload_hash: payloadHash } = signableResultData;
@@ -4843,8 +4730,10 @@ async function transfer({ request, transfersApi, starkSigner, user, imxPublicApi
         };
     }, PassportErrorType.TRANSFER_ERROR);
 }
-async function batchNftTransfer({ user, starkSigner, request, transfersApi, confirmationScreen, }) {
+async function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }) {
     return withPassportError(async () => {
+        const popupWindowSize = { width: 480, height: 784 };
+        guardianClient.loading(popupWindowSize);
         const { ethAddress } = user.imx;
         const signableRequests = request.map((nftTransfer) => ({
             amount: '1',
@@ -4859,17 +4748,16 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, conf
             sender_ether_key: ethAddress,
             signable_requests: signableRequests,
         };
+        const headers = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
+        };
         const signableResult = await transfersApi.getSignableTransfer({
             getSignableTransferRequestV2,
+        }, { headers });
+        await guardianClient.validate({
+            payloadHash: signableResult.data.signable_responses[0]?.payload_hash,
         });
-        const popupWindowSize = { width: 480, height: 784 };
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.createBatchTransfer,
-            transactionData: getSignableTransferRequestV2,
-        }, popupWindowSize);
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
         const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
             const starkSignature = await starkSigner.signMessage(resp.payload_hash);
             return {
@@ -4887,10 +4775,6 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, conf
             sender_stark_key: signableResult.data.sender_stark_key,
             requests,
         };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
         const response = await transfersApi.createTransfer({
             createTransferRequestV2: transferSigningParams,
         }, { headers });
@@ -4905,13 +4789,18 @@ class PassportImxProvider {
     starkSigner;
     immutableXClient;
     confirmationScreen;
-    imxPublicApiDomain;
+    guardianClient;
     constructor({ user, starkSigner, immutableXClient, imxPublicApiDomain, confirmationScreen, }) {
         this.user = user;
         this.starkSigner = starkSigner;
         this.immutableXClient = immutableXClient;
-        this.imxPublicApiDomain = imxPublicApiDomain;
         this.confirmationScreen = confirmationScreen;
+        this.guardianClient = new GuardianClient({
+            imxPublicApiDomain,
+            accessToken: user.accessToken,
+            confirmationScreen,
+            imxEtherAddress: user.imx.ethAddress,
+        });
     }
     async transfer(request) {
         return transfer({
@@ -4919,8 +4808,7 @@ class PassportImxProvider {
             user: this.user,
             starkSigner: this.starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
-            confirmationScreen: this.confirmationScreen,
-            imxPublicApiDomain: this.imxPublicApiDomain,
+            guardianClient: this.guardianClient,
         });
     }
     // TODO: Remove once implemented
@@ -4939,7 +4827,7 @@ class PassportImxProvider {
             user: this.user,
             starkSigner: this.starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
-            confirmationScreen: this.confirmationScreen,
+            guardianClient: this.guardianClient,
         });
     }
     cancelOrder(request) {
@@ -4948,7 +4836,7 @@ class PassportImxProvider {
             user: this.user,
             starkSigner: this.starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
-            confirmationScreen: this.confirmationScreen,
+            guardianClient: this.guardianClient,
         });
     }
     createTrade(request) {
@@ -4957,7 +4845,7 @@ class PassportImxProvider {
             user: this.user,
             starkSigner: this.starkSigner,
             tradesApi: this.immutableXClient.tradesApi,
-            confirmationScreen: this.confirmationScreen,
+            guardianClient: this.guardianClient,
         });
     }
     batchNftTransfer(request) {
@@ -4966,7 +4854,7 @@ class PassportImxProvider {
             user: this.user,
             starkSigner: this.starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
-            confirmationScreen: this.confirmationScreen,
+            guardianClient: this.guardianClient,
         });
     }
     exchangeTransfer(request) {
@@ -5149,6 +5037,159 @@ class PassportConfiguration {
     }
 }
 
+var ReceiveMessage;
+(function (ReceiveMessage) {
+    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
+    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
+    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
+})(ReceiveMessage || (ReceiveMessage = {}));
+var SendMessage;
+(function (SendMessage) {
+    SendMessage["TRANSACTION_START"] = "transaction_start";
+})(SendMessage || (SendMessage = {}));
+var TransactionTypes;
+(function (TransactionTypes) {
+    TransactionTypes["cancelOrder"] = "delete:v1/orders";
+    TransactionTypes["createOrder"] = "post:v1/orders";
+    TransactionTypes["createTrade"] = "post:v1/trades";
+    TransactionTypes["createTransfer"] = "post:v1/transfers";
+    TransactionTypes["createBatchTransfer"] = "post:v2/transfers";
+})(TransactionTypes || (TransactionTypes = {}));
+const PASSPORT_EVENT_TYPE = 'imx_passport_confirmation';
+
+const openPopupCenter = ({ url, title, width, height, }) => {
+    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
+    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
+    const newWindow = window.open(url, title, `
+      scrollbars=yes,
+      width=${width}, 
+      height=${height}, 
+      top=${top}, 
+      left=${left}
+     `);
+    if (!newWindow) {
+        throw new Error('Failed to open confirmation screen');
+    }
+    newWindow.focus();
+    return newWindow;
+};
+
+const CONFIRMATION_WINDOW_TITLE = 'Confirm this transaction';
+const CONFIRMATION_WINDOW_HEIGHT = 380;
+const CONFIRMATION_WINDOW_WIDTH = 480;
+const CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION = 1000;
+class ConfirmationScreen {
+    config;
+    confirmationWindow;
+    constructor(config) {
+        this.config = config;
+    }
+    postMessage(destinationWindow, accessToken, message) {
+        destinationWindow.postMessage({
+            eventType: PASSPORT_EVENT_TYPE,
+            accessToken,
+            ...message,
+        }, this.config.passportDomain);
+    }
+    startTransaction(accessToken, transaction, popupOptions) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin !== this.config.passportDomain
+                    || data.eventType !== PASSPORT_EVENT_TYPE) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        // TODO: remove once fixed
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                        this.postMessage(confirmationWindow, accessToken, {
+                            messageType: SendMessage.TRANSACTION_START,
+                            messageData: transaction,
+                        });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_ERROR: {
+                        reject(new Error('Transaction error'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
+                }
+            };
+            window.addEventListener('message', messageHandler);
+            const confirmationWindow = openPopupCenter({
+                url: `${this.config.passportDomain}/transaction-confirmation`,
+                title: CONFIRMATION_WINDOW_TITLE,
+                width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+                height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+            });
+            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+            const timer = setInterval(() => {
+                if (confirmationWindow.closed) {
+                    clearInterval(timer);
+                    window.removeEventListener('message', messageHandler);
+                    resolve({ confirmed: false });
+                }
+            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+        });
+    }
+    startGuardianTransaction(transactionId, imxEtherAddress) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin !== this.config.passportDomain
+                    || data.eventType !== PASSPORT_EVENT_TYPE) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_ERROR: {
+                        reject(new Error('Transaction error'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
+                }
+            };
+            window.addEventListener('message', messageHandler);
+            if (!this.confirmationWindow) {
+                resolve({ confirmed: false });
+                return;
+            }
+            // eslint-disable-next-line max-len
+            this.confirmationWindow.location.href = `${this.config.passportDomain}/transaction-confirmation/transaction.html?transactionId=${transactionId}&imxEtherAddress=${imxEtherAddress}&chainType=starkex`;
+            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+            const timer = setInterval(() => {
+                if (this.confirmationWindow?.closed) {
+                    clearInterval(timer);
+                    window.removeEventListener('message', messageHandler);
+                    resolve({ confirmed: false });
+                }
+            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
+        });
+    }
+    loading(popupOptions) {
+        this.confirmationWindow = openPopupCenter({
+            url: `${this.config.passportDomain}/transaction-confirmation/loading.html`,
+            title: CONFIRMATION_WINDOW_TITLE,
+            width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+            height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
+        });
+    }
+    closeWindow() {
+        this.confirmationWindow?.close();
+    }
+}
+
 class Passport {
     authManager;
     config;