@imtbl/sdk 0.1.7-alpha.1 → 0.1.7

package/dist/index.cjs

@@ -1,23 +1,15 @@
 'use strict';
 
 var coreSdk = require('@imtbl/core-sdk');
-var guardian = require('@imtbl/guardian');
 var oidcClientTs = require('oidc-client-ts');
 var ethers = require('ethers');
 var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
 var BN = require('bn.js');
 var encUtils = require('enc-utils');
-var constants = require('@opensea/seaport-js/lib/constants');
-var FormData = require('form-data');
-var fetch = require('node-fetch');
-var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
 var detectEthereumProvider = require('@metamask/detect-provider');
-var providers = require('@ethersproject/providers');
-var jsxRuntime = require('react/jsx-runtime');
-require('react');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -36,7 +28,6 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
-var guardian__namespace = /*#__PURE__*/_interopNamespaceDefault(guardian);
 var encUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(encUtils);
 
 exports.Environment = void 0;
@@ -1032,12 +1023,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
     }, PassportErrorType.TRANSFER_ERROR);
 }
 
-const ERC721$2 = 'ERC721';
+const ERC721 = 'ERC721';
 async function createOrder$1({ starkSigner, user, request, ordersApi, passportConfig, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
-        const amountSell = request.sell.type === ERC721$2 ? '1' : request.sell.amount;
-        const amountBuy = request.buy.type === ERC721$2 ? '1' : request.buy.amount;
+        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
+        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
         const getSignableOrderRequestV3 = {
             user: ethAddress,
             amount_buy: amountBuy,
@@ -1505,2508 +1496,682 @@ class Passport {
     }
 }
 
-class BaseHttpRequest {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
+function isChainValid(chainID, config) {
+    return chainID === config.ethConfiguration.chainID;
 }
-
-class ApiError extends Error {
-    url;
-    status;
-    statusText;
-    body;
-    request;
-    constructor(request, response, message) {
-        super(message);
-        this.name = 'ApiError';
-        this.url = response.url;
-        this.status = response.status;
-        this.statusText = response.statusText;
-        this.body = response.body;
-        this.request = request;
+async function validateChain(signer, config) {
+    const chainID = await signer.getChainId();
+    if (!isChainValid(chainID, config)) {
+        throw new Error('The wallet used for this operation is not connected to the correct network.');
     }
 }
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-class CancelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CancelError';
-    }
-    get isCancelled() {
-        return true;
-    }
+async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
+    const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
+    const signableResult = await transfersApi.getSignableTransferV1({
+        getSignableTransferRequest: {
+            sender: ethAddress,
+            token: convertToSignableToken(request),
+            amount: transferAmount,
+            receiver: request.receiver,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        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 response = await transfersApi.createTransferV1({
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
 }
-class CancelablePromise {
-    [Symbol.toStringTag];
-    _isResolved;
-    _isRejected;
-    _isCancelled;
-    _cancelHandlers;
-    _promise;
-    _resolve;
-    _reject;
-    constructor(executor) {
-        this._isResolved = false;
-        this._isRejected = false;
-        this._isCancelled = false;
-        this._cancelHandlers = [];
-        this._promise = new Promise((resolve, reject) => {
-            this._resolve = resolve;
-            this._reject = reject;
-            const onResolve = (value) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._isResolved = true;
-                this._resolve?.(value);
-            };
-            const onReject = (reason) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._isRejected = true;
-                this._reject?.(reason);
-            };
-            const onCancel = (cancelHandler) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._cancelHandlers.push(cancelHandler);
-            };
-            Object.defineProperty(onCancel, 'isResolved', {
-                get: () => this._isResolved,
-            });
-            Object.defineProperty(onCancel, 'isRejected', {
-                get: () => this._isRejected,
-            });
-            Object.defineProperty(onCancel, 'isCancelled', {
-                get: () => this._isCancelled,
-            });
-            return executor(onResolve, onReject, onCancel);
-        });
-    }
-    then(onFulfilled, onRejected) {
-        return this._promise.then(onFulfilled, onRejected);
-    }
-    catch(onRejected) {
-        return this._promise.catch(onRejected);
-    }
-    finally(onFinally) {
-        return this._promise.finally(onFinally);
-    }
-    cancel() {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
-            return;
-        }
-        this._isCancelled = true;
-        if (this._cancelHandlers.length) {
-            try {
-                for (const cancelHandler of this._cancelHandlers) {
-                    cancelHandler();
-                }
-            }
-            catch (error) {
-                console.warn('Cancellation threw an error', error);
-                return;
-            }
-        }
-        this._cancelHandlers.length = 0;
-        this._reject?.(new CancelError('Request aborted'));
+async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
+    const signableRequests = request.map((nftTransfer) => ({
+        amount: '1',
+        token: convertToSignableToken({
+            type: 'ERC721',
+            tokenId: nftTransfer.tokenId,
+            tokenAddress: nftTransfer.tokenAddress,
+        }),
+        receiver: nftTransfer.receiver,
+    }));
+    const signableResult = await transfersApi.getSignableTransfer({
+        getSignableTransferRequestV2: {
+            sender_ether_key: ethAddress,
+            signable_requests: signableRequests,
+        },
+    });
+    const signableMessage = signableResult.data.signable_message;
+    if (signableMessage === undefined) {
+        throw new Error('Invalid response from Signable registration offchain');
     }
-    get isCancelled() {
-        return this._isCancelled;
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const requests = [];
+    for (const resp of signableResult.data.signable_responses) {
+        // TODO: remove once fixed
+        // eslint-disable-next-line no-await-in-loop
+        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+        const req = {
+            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,
+        };
+        requests.push(req);
     }
+    // TODO: throw error on missing payload hash?
+    const transferSigningParams = {
+        sender_stark_key: signableResult.data.sender_stark_key,
+        requests,
+    };
+    const response = await transfersApi.createTransfer({
+        createTransferRequestV2: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        transfer_ids: response?.data.transfer_ids,
+    };
 }
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-const isDefined = (value) => {
-    return value !== undefined && value !== null;
-};
-const isString = (value) => {
-    return typeof value === 'string';
-};
-const isStringWithValue = (value) => {
-    return isString(value) && value !== '';
-};
-const isBlob = (value) => {
-    return (typeof value === 'object' &&
-        typeof value.type === 'string' &&
-        typeof value.stream === 'function' &&
-        typeof value.arrayBuffer === 'function' &&
-        typeof value.constructor === 'function' &&
-        typeof value.constructor.name === 'string' &&
-        /^(Blob|File)$/.test(value.constructor.name) &&
-        /^(Blob|File)$/.test(value[Symbol.toStringTag]));
-};
-const isFormData = (value) => {
-    return value instanceof FormData;
-};
-const base64 = (str) => {
-    try {
-        return btoa(str);
-    }
-    catch (err) {
-        // @ts-ignore
-        return Buffer.from(str).toString('base64');
-    }
-};
-const getQueryString = (params) => {
-    const qs = [];
-    const append = (key, value) => {
-        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+async function createOrder({ signers, request, config, }) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
+    const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
+    const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
+    const getSignableOrderRequest = {
+        user: ethAddress,
+        amount_buy: amountBuy,
+        token_buy: convertToSignableToken(request.buy),
+        amount_sell: amountSell,
+        token_sell: convertToSignableToken(request.sell),
+        fees: request.fees,
+        expiration_timestamp: request.expiration_timestamp,
     };
-    const process = (key, value) => {
-        if (isDefined(value)) {
-            if (Array.isArray(value)) {
-                value.forEach(v => {
-                    process(key, v);
-                });
-            }
-            else if (typeof value === 'object') {
-                Object.entries(value).forEach(([k, v]) => {
-                    process(`${key}[${k}]`, v);
-                });
-            }
-            else {
-                append(key, value);
-            }
-        }
+    const getSignableOrderResponse = await ordersApi.getSignableOrder({
+        getSignableOrderRequestV3: getSignableOrderRequest,
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const resp = getSignableOrderResponse.data;
+    const orderParams = {
+        createOrderRequest: {
+            amount_buy: resp.amount_buy,
+            amount_sell: resp.amount_sell,
+            asset_id_buy: resp.asset_id_buy,
+            asset_id_sell: resp.asset_id_sell,
+            expiration_timestamp: resp.expiration_timestamp,
+            include_fees: true,
+            fees: request.fees,
+            nonce: resp.nonce,
+            stark_key: resp.stark_key,
+            stark_signature: starkSignature,
+            vault_id_buy: resp.vault_id_buy,
+            vault_id_sell: resp.vault_id_sell,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    };
+    const createOrderResponse = await ordersApi.createOrder(orderParams);
+    return {
+        ...createOrderResponse.data,
+    };
+}
+async function cancelOrder({ signers, request, config, }) {
+    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
+    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
+        getSignableCancelOrderRequest: {
+            order_id: request.order_id,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const cancelOrderResponse = await ordersApi.cancelOrder({
+        id: request.order_id.toString(),
+        cancelOrderRequest: {
+            order_id: request.order_id,
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        order_id: cancelOrderResponse.data.order_id,
+        status: cancelOrderResponse.data.status,
     };
-    Object.entries(params).forEach(([key, value]) => {
-        process(key, value);
+}
+
+async function registerOffchain(signers, config) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
+    const userAddress = await signers.ethSigner.getAddress();
+    const starkPublicKey = await signers.starkSigner.getAddress();
+    const signableResult = await usersApi.getSignableRegistrationOffchain({
+        getSignableRegistrationRequest: {
+            ether_key: userAddress,
+            stark_key: starkPublicKey,
+        },
     });
-    if (qs.length > 0) {
-        return `?${qs.join('&')}`;
-    }
-    return '';
-};
-const getUrl = (config, options) => {
-    const encoder = config.ENCODE_PATH || encodeURI;
-    const path = options.url
-        .replace('{api-version}', config.VERSION)
-        .replace(/{(.*?)}/g, (substring, group) => {
-        if (options.path?.hasOwnProperty(group)) {
-            return encoder(String(options.path[group]));
-        }
-        return substring;
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const registeredUser = await usersApi.registerUser({
+        registerUserRequest: {
+            eth_signature: ethSignature,
+            ether_key: userAddress,
+            stark_signature: starkSignature,
+            stark_key: starkPublicKey,
+        },
     });
-    const url = `${config.BASE}${path}`;
-    if (options.query) {
-        return `${url}${getQueryString(options.query)}`;
+    return registeredUser.data;
+}
+async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const registrationContract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    try {
+        return await registrationContract.isRegistered(starkPublicKey);
     }
-    return url;
-};
-const getFormData = (options) => {
-    if (options.formData) {
-        const formData = new FormData();
-        const process = (key, value) => {
-            if (isString(value) || isBlob(value)) {
-                formData.append(key, value);
-            }
-            else {
-                formData.append(key, JSON.stringify(value));
-            }
-        };
-        Object.entries(options.formData)
-            .filter(([_, value]) => isDefined(value))
-            .forEach(([key, value]) => {
-            if (Array.isArray(value)) {
-                value.forEach(v => process(key, v));
-            }
-            else {
-                process(key, value);
-            }
-        });
-        return formData;
+    catch (ex) {
+        if (ex.reason === 'USER_UNREGISTERED') {
+            return false;
+        }
+        throw ex;
     }
-    return undefined;
-};
-const resolve = async (options, resolver) => {
-    if (typeof resolver === 'function') {
-        return resolver(options);
-    }
-    return resolver;
-};
-const getHeaders = async (config, options) => {
-    const token = await resolve(options, config.TOKEN);
-    const username = await resolve(options, config.USERNAME);
-    const password = await resolve(options, config.PASSWORD);
-    const additionalHeaders = await resolve(options, config.HEADERS);
-    const headers = Object.entries({
-        Accept: 'application/json',
-        ...additionalHeaders,
-        ...options.headers,
-    })
-        .filter(([_, value]) => isDefined(value))
-        .reduce((headers, [key, value]) => ({
-        ...headers,
-        [key]: String(value),
-    }), {});
-    if (isStringWithValue(token)) {
-        headers['Authorization'] = `Bearer ${token}`;
-    }
-    if (isStringWithValue(username) && isStringWithValue(password)) {
-        const credentials = base64(`${username}:${password}`);
-        headers['Authorization'] = `Basic ${credentials}`;
-    }
-    if (options.body) {
-        if (options.mediaType) {
-            headers['Content-Type'] = options.mediaType;
-        }
-        else if (isBlob(options.body)) {
-            headers['Content-Type'] = 'application/octet-stream';
-        }
-        else if (isString(options.body)) {
-            headers['Content-Type'] = 'text/plain';
-        }
-        else if (!isFormData(options.body)) {
-            headers['Content-Type'] = 'application/json';
-        }
-    }
-    return new fetch.Headers(headers);
-};
-const getRequestBody = (options) => {
-    if (options.body) {
-        if (options.mediaType?.includes('/json')) {
-            return JSON.stringify(options.body);
-        }
-        else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
-            return options.body;
-        }
-        else {
-            return JSON.stringify(options.body);
-        }
-    }
-    return undefined;
-};
-const sendRequest = async (options, url, body, formData, headers, onCancel) => {
-    const controller = new AbortController();
-    const request = {
-        headers,
-        method: options.method,
-        body: body ?? formData,
-        signal: controller.signal,
-    };
-    onCancel(() => controller.abort());
-    return await fetch(url, request);
-};
-const getResponseHeader = (response, responseHeader) => {
-    if (responseHeader) {
-        const content = response.headers.get(responseHeader);
-        if (isString(content)) {
-            return content;
-        }
-    }
-    return undefined;
-};
-const getResponseBody = async (response) => {
-    if (response.status !== 204) {
-        try {
-            const contentType = response.headers.get('Content-Type');
-            if (contentType) {
-                const isJSON = contentType.toLowerCase().startsWith('application/json');
-                if (isJSON) {
-                    return await response.json();
-                }
-                else {
-                    return await response.text();
-                }
-            }
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-    return undefined;
-};
-const catchErrorCodes = (options, result) => {
-    const errors = {
-        400: 'Bad Request',
-        401: 'Unauthorized',
-        403: 'Forbidden',
-        404: 'Not Found',
-        500: 'Internal Server Error',
-        502: 'Bad Gateway',
-        503: 'Service Unavailable',
-        ...options.errors,
+}
+async function getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi) {
+    const response = await usersApi.getSignableRegistration({
+        getSignableRegistrationRequest: {
+            ether_key: etherKey,
+            stark_key: starkPublicKey,
+        },
+    });
+    return {
+        operator_signature: response.data.operator_signature,
+        payload_hash: response.data.payload_hash,
     };
-    const error = errors[result.status];
-    if (error) {
-        throw new ApiError(options, result, error);
-    }
-    if (!result.ok) {
-        throw new ApiError(options, result, 'Generic Error');
-    }
+}
+
+const assertIsDefined = (value) => {
+    if (value !== undefined)
+        return value;
+    throw new Error('undefined field exception');
 };
-/**
- * Request method
- * @param config The OpenAPI configuration object
- * @param options The request options from the service
- * @returns CancelablePromise<T>
- * @throws ApiError
- */
-const request = (config, options) => {
-    return new CancelablePromise(async (resolve, reject, onCancel) => {
-        try {
-            const url = getUrl(config, options);
-            const formData = getFormData(options);
-            const body = getRequestBody(options);
-            const headers = await getHeaders(config, options);
-            if (!onCancel.isCancelled) {
-                const response = await sendRequest(options, url, body, formData, headers, onCancel);
-                const responseBody = await getResponseBody(response);
-                const responseHeader = getResponseHeader(response, options.responseHeader);
-                const result = {
-                    url,
-                    ok: response.ok,
-                    status: response.status,
-                    statusText: response.statusText,
-                    body: responseHeader ?? responseBody,
-                };
-                catchErrorCodes(options, result);
-                resolve(result.body);
-            }
-        }
-        catch (error) {
-            reject(error);
-        }
+async function prepareWithdrawalAction(params) {
+    const { signers: { ethSigner, starkSigner }, type, config, } = params;
+    await validateChain(ethSigner, params.config);
+    const withdrawalsApi = new coreSdk.WithdrawalsApi(config.apiConfiguration);
+    const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
+    const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawal({
+        getSignableWithdrawalRequest: {
+            user: await ethSigner.getAddress(),
+            token: convertToSignableToken(params),
+            amount: withdrawalAmount,
+        },
     });
-};
-
-class NodeHttpRequest extends BaseHttpRequest {
-    constructor(config) {
-        super(config);
-    }
-    /**
-     * Request method
-     * @param options The request options from the service
-     * @returns CancelablePromise<T>
-     * @throws ApiError
-     */
-    request(options) {
-        return request(this.config, options);
-    }
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const { ethAddress, ethSignature } = await signMessage(signableMessage, ethSigner);
+    const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
+        createWithdrawalRequest: {
+            stark_key: assertIsDefined(signableWithdrawalResult.data.stark_key),
+            amount: withdrawalAmount,
+            asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
+            vault_id: assertIsDefined(signableWithdrawalResult.data.vault_id),
+            nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return prepareWithdrawalResponse.data;
 }
 
-class OrdersService {
-    httpRequest;
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * List all orders
-     * List all orders
-     * @returns Orders OK response.
-     * @throws ApiError
-     */
-    listOrders({ chainId, pageSize = 100, sortBy, sortDirection, pageCursor, }) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/v1/chains/{chain_id}/orders',
-            path: {
-                'chain_id': chainId,
-            },
-            query: {
-                'page_size': pageSize,
-                'sort_by': sortBy,
-                'sort_direction': sortDirection,
-                'page_cursor': pageCursor,
-            },
-            errors: {
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
-            },
-        });
-    }
-    /**
-     * Create an order
-     * Create an order
-     * @returns Order Created response.
-     * @throws ApiError
-     */
-    createOrder({ chainId, requestBody, }) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/v1/chains/{chain_id}/orders',
-            path: {
-                'chain_id': chainId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `bad_request: Bad Request`,
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
-            },
-        });
-    }
-    /**
-     * Get a single order by ID
-     * Get a single order by ID
-     * @returns Order OK response.
-     * @throws ApiError
-     */
-    getOrder({ chainId, orderId, }) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/v1/chains/{chain_id}/orders/{order_id}',
-            path: {
-                'chain_id': chainId,
-                'order_id': orderId,
-            },
-            errors: {
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
+async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
+    const encodingApi = new coreSdk.EncodingApi(config.apiConfiguration);
+    const result = await encodingApi.encodeAsset({
+        assetType,
+        encodeAssetRequest: {
+            token: {
+                type: tokenType,
+                ...(tokenData && { data: tokenData }),
             },
-        });
-    }
+        },
+    });
+    return result.data;
 }
 
-class OrderBookClient {
-    orders;
-    request;
-    constructor(config, HttpRequest = NodeHttpRequest) {
-        this.request = new HttpRequest({
-            BASE: config?.BASE ?? 'https://order-book-mr.dev.imtbl.com',
-            VERSION: config?.VERSION ?? '1.0.0',
-            WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
-            CREDENTIALS: config?.CREDENTIALS ?? 'include',
-            TOKEN: config?.TOKEN,
-            USERNAME: config?.USERNAME,
-            PASSWORD: config?.PASSWORD,
-            HEADERS: config?.HEADERS,
-            ENCODE_PATH: config?.ENCODE_PATH,
-        });
-        this.orders = new OrdersService(this.request);
-    }
+async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
+    const etherKey = await ethSigner.getAddress();
+    const imxConfig = config.immutableXConfig;
+    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var BuyItem;
-(function (BuyItem) {
-    (function (item_type) {
-        item_type["ERC20"] = "ERC20";
-        item_type["IMX"] = "IMX";
-    })(BuyItem.item_type || (BuyItem.item_type = {}));
-})(BuyItem || (BuyItem = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var CreateOrderProtocolData;
-(function (CreateOrderProtocolData) {
-    (function (order_type) {
-        order_type["FULL_OPEN"] = "FULL_OPEN";
-    })(CreateOrderProtocolData.order_type || (CreateOrderProtocolData.order_type = {}));
-})(CreateOrderProtocolData || (CreateOrderProtocolData = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var Fee;
-(function (Fee) {
-    (function (fee_type) {
-        fee_type["ROYALTY"] = "ROYALTY";
-    })(Fee.fee_type || (Fee.fee_type = {}));
-})(Fee || (Fee = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var Order;
-(function (Order) {
-    (function (status) {
-        status["PENDING"] = "PENDING";
-        status["ACTIVE"] = "ACTIVE";
-        status["CANCELLED"] = "CANCELLED";
-        status["INACTIVE"] = "INACTIVE";
-        status["REJECTED"] = "REJECTED";
-        status["FILLED"] = "FILLED";
-        status["EXPIRED"] = "EXPIRED";
-    })(Order.status || (Order.status = {}));
-})(Order || (Order = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var SellItem;
-(function (SellItem) {
-    (function (item_type) {
-        item_type["ERC721"] = "ERC721";
-    })(SellItem.item_type || (SellItem.item_type = {}));
-})(SellItem || (SellItem = {}));
-
-class ImmutableApiClient {
-    orderbookService;
-    chainId;
-    constructor(orderbookService, chainId) {
-        this.orderbookService = orderbookService;
-        this.chainId = chainId;
-    }
-    async getOrder(orderId) {
-        return this.orderbookService.getOrder({ chainId: this.chainId, orderId });
-    }
-    async createOrder({ orderHash, orderComponents, offerer, orderSignature, }) {
-        if (orderComponents.offer.length !== 1) {
-            throw new Error('Only one item can be listed at a time');
-        }
-        if (Number(orderComponents.offer[0].itemType) !== constants.ItemType.ERC721) {
-            throw new Error('Only ERC721 tokens can be listed');
-        }
-        const considerationItemTypeTheSame = new Set([...orderComponents.consideration.map((c) => c.itemType)]).size === 1;
-        if (!considerationItemTypeTheSame) {
-            throw new Error('All consideration items must be of the same type');
-        }
-        return this.orderbookService.createOrder({
-            chainId: this.chainId,
-            requestBody: {
-                order_hash: orderHash,
-                account_address: offerer,
-                buy: [
-                    {
-                        item_type: Number(orderComponents.consideration[0].itemType) === constants.ItemType.NATIVE
-                            ? BuyItem.item_type.IMX
-                            : BuyItem.item_type.ERC20,
-                        start_amount: orderComponents.consideration[0].startAmount,
-                    }
-                ],
-                buy_fees: orderComponents.consideration.length > 1
-                    ? [
-                        {
-                            amount: orderComponents.consideration[1].startAmount,
-                            recipient: orderComponents.consideration[1].recipient,
-                            fee_type: Fee.fee_type.ROYALTY,
-                        },
-                    ]
-                    : [],
-                end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
-                protocol_data: {
-                    order_type: CreateOrderProtocolData.order_type.FULL_OPEN,
-                    zone_address: orderComponents.zone,
-                },
-                salt: orderComponents.salt,
-                sell: [{
-                        contract_address: orderComponents.offer[0].token,
-                        token_id: orderComponents.offer[0].identifierOrCriteria,
-                        item_type: SellItem.item_type.ERC721,
-                    }],
-                signature: orderSignature,
-                start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
-            },
-        });
-    }
+async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
-class ImmutableApiClientFactory {
-    chainId;
-    orderbookClient;
-    constructor(apiEndpoint, chainId) {
-        this.chainId = chainId;
-        this.orderbookClient = new OrderBookClient({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            BASE: apiEndpoint,
+async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC20({
+            ethSigner,
+            assetType: assetType.asset_type,
+            starkPublicKey,
+            config,
         });
     }
-    create() {
-        return new ImmutableApiClient(this.orderbookClient.orders, this.chainId);
-    }
+    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
-class ERC721 {
-    erc721;
-    constructor(erc721) {
-        this.erc721 = erc721;
+async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+function getMintingBlob(token) {
+    const { id } = token.data;
+    const blueprint = token.data.blueprint || '';
+    return encUtils__namespace.sanitizeHex(encUtils__namespace.utf8ToHex(`{${id}}:{${blueprint}}`));
+}
+async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
+        id: token.data.id,
+        token_address: token.data.tokenAddress,
+        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
+    });
+    const mintingBlob = getMintingBlob(token);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    async royaltyInfo(tokenId, salePrice) {
-        const [recipient, royaltyRequired] = await this.erc721.royaltyInfo(tokenId, salePrice);
-        return { recipient, amountRequired: royaltyRequired.toString() };
+    return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
+}
+async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
+        token_id: token.tokenId,
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
+    return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
+}
+async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const { tokenAddress } = token;
+    const { tokenId } = token;
+    const imxConfig = config.immutableXConfig;
+    const mintsApi = new coreSdk.MintsApi(imxConfig.apiConfiguration);
+    return await mintsApi
+        .getMintableTokenDetailsByClientTokenId({
+        tokenAddress,
+        tokenId,
+    })
+        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
+        type: 'ERC721',
+        data: {
+            id: tokenId,
+            tokenAddress,
+            blueprint: mintableToken.data.blueprint,
+        },
+    }, config))
+        .catch((error) => {
+        if (error.response?.status === 404) {
+            // token is already minted on L1
+            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
+        }
+        throw error; // unable to recover from any other kind of error
+    });
 }
 
-/* Autogenerated file. Do not edit manually. */
-/* tslint:disable */
-/* eslint-disable */
-const _abi = [
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner_",
-                type: "address",
-            },
-            {
-                internalType: "string",
-                name: "name_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "symbol_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "baseURI_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "contractURI_",
-                type: "string",
-            },
-            {
-                internalType: "address",
-                name: "_receiver",
-                type: "address",
-            },
-            {
-                internalType: "uint96",
-                name: "_feeNumerator",
-                type: "uint96",
-            },
-        ],
-        stateMutability: "nonpayable",
-        type: "constructor",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "target",
-                type: "address",
-            },
-        ],
-        name: "ApproveTargetNotInAllowlist",
-        type: "error",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "caller",
-                type: "address",
-            },
-        ],
-        name: "CallerNotInAllowlist",
-        type: "error",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "approved",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "Approval",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-            {
-                indexed: false,
-                internalType: "bool",
-                name: "approved",
-                type: "bool",
-            },
-        ],
-        name: "ApprovalForAll",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "previousAdminRole",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "newAdminRole",
-                type: "bytes32",
-            },
-        ],
-        name: "RoleAdminChanged",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "sender",
-                type: "address",
-            },
-        ],
-        name: "RoleGranted",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "sender",
-                type: "address",
-            },
-        ],
-        name: "RoleRevoked",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: false,
-                internalType: "address",
-                name: "oldRegistry",
-                type: "address",
-            },
-            {
-                indexed: false,
-                internalType: "address",
-                name: "newRegistry",
-                type: "address",
-            },
-        ],
-        name: "RoyaltytAllowlistRegistryUpdated",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "Transfer",
-        type: "event",
-    },
-    {
-        inputs: [],
-        name: "DEFAULT_ADMIN_ROLE",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "MINTER_ROLE",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "approve",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-        ],
-        name: "balanceOf",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "baseURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "burn",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "contractURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getAdmins",
-        outputs: [
-            {
-                internalType: "address[]",
-                name: "",
-                type: "address[]",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "getApproved",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-        ],
-        name: "getRoleAdmin",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "getRoleMember",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-        ],
-        name: "getRoleMemberCount",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "user",
-                type: "address",
-            },
-        ],
-        name: "grantMinterRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "grantRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "hasRole",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-        ],
-        name: "isApprovedForAll",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "amount",
-                type: "uint256",
-            },
-        ],
-        name: "mint",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "name",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "ownerOf",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "renounceRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "user",
-                type: "address",
-            },
-        ],
-        name: "revokeMinterRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "revokeRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "royaltyAllowlist",
-        outputs: [
-            {
-                internalType: "contract IRoyaltyAllowlist",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "_tokenId",
-                type: "uint256",
-            },
-            {
-                internalType: "uint256",
-                name: "_salePrice",
-                type: "uint256",
-            },
-        ],
-        name: "royaltyInfo",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "safeTransferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-            {
-                internalType: "bytes",
-                name: "data",
-                type: "bytes",
-            },
-        ],
-        name: "safeTransferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-            {
-                internalType: "bool",
-                name: "approved",
-                type: "bool",
-            },
-        ],
-        name: "setApprovalForAll",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "string",
-                name: "baseURI_",
-                type: "string",
-            },
-        ],
-        name: "setBaseURI",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "string",
-                name: "_contractURI",
-                type: "string",
-            },
-        ],
-        name: "setContractURI",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "_royaltyAllowlist",
-                type: "address",
-            },
-        ],
-        name: "setRoyaltyAllowlistRegistry",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes4",
-                name: "interfaceId",
-                type: "bytes4",
-            },
-        ],
-        name: "supportsInterface",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "symbol",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "tokenByIndex",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "tokenOfOwnerByIndex",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "tokenURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalSupply",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "transferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-];
-class ImmutableERC721Base__factory {
-    static abi = _abi;
-    static createInterface() {
-        return new ethers.utils.Interface(_abi);
-    }
-    static connect(address, signerOrProvider) {
-        return new ethers.Contract(address, _abi, signerOrProvider);
-    }
-}
-
-class ERC721Factory {
-    erc721;
-    constructor(contractAddress, provider) {
-        this.erc721 = ImmutableERC721Base__factory.connect(contractAddress, provider);
-    }
-    create() {
-        return new ERC721(this.erc721);
-    }
-}
-
-function getOrderComponentsFromMessage(orderMessage) {
-    const data = JSON.parse(orderMessage);
-    const orderComponents = data.message;
-    orderComponents.salt = ethers.BigNumber.from(orderComponents.salt).toHexString();
-    return orderComponents;
-}
-
-// Add 20% more gas than estimate to prevent out of gas errors
-// This can always be overwritten by the user signing the transaction
-async function prepareTransaction(transactionMethods) {
-    const transaction = await transactionMethods.buildTransaction();
-    transaction.gasLimit = await transactionMethods.estimateGas();
-    transaction.gasLimit = transaction.gasLimit
-        .add(transaction.gasLimit.div(5));
-    return transaction;
-}
-
-function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
-    const considerationItems = order.buy.map((buyItem) => ({
-        startAmount: buyItem.start_amount,
-        endAmount: buyItem.start_amount,
-        itemType: buyItem.item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
-        recipient: order.account_address,
-        token: buyItem.contract_address || ethers.constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    const fees = order.buy_fees.map((fee) => ({
-        startAmount: fee.amount,
-        endAmount: fee.amount,
-        itemType: order.buy[0].item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
-        recipient: fee.recipient,
-        token: order.buy[0].contract_address || ethers.constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    return {
-        conduitKey: ethers.constants.HashZero,
-        consideration: [...considerationItems, ...fees],
-        offer: order.sell.map((sellItem) => ({
-            startAmount: '1',
-            endAmount: '1',
-            itemType: constants.ItemType.ERC721,
-            token: sellItem.contract_address,
-            identifierOrCriteria: sellItem.token_id,
-        })),
-        counter,
-        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
-        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
-        salt: order.salt,
-        offerer: order.account_address,
-        zone: zoneAddress,
-        totalOriginalConsiderationItems: 2,
-        orderType: constants.OrderType.FULL_RESTRICTED,
-        zoneHash: ethers.constants.HashZero,
-    };
-}
-
-class Seaport {
-    seaport;
-    provider;
-    seaportContractAddress;
-    zoneContractAddress;
-    constructor(seaport, provider, seaportContractAddress, zoneContractAddress) {
-        this.seaport = seaport;
-        this.provider = provider;
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-    }
-    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const createAction = actions
-            .find((action) => action.type === 'create');
-        if (!createAction) {
-            throw new Error('No create order action found');
-        }
-        const orderMessageToSign = await createAction.getMessageToSign();
-        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
-            orderComponents,
-            orderHash: await this.seaport.getOrderHash(orderComponents),
-        };
-    }
-    async fulfilOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const { actions } = await this.seaport.fulfillOrders({
-            accountAddress: account,
-            fulfillOrderDetails: [{
-                    order: {
-                        parameters: orderComponents,
-                        signature: order.signature,
-                    },
-                }],
-        });
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const fulfillmentAction = actions
-            .find((action) => action.type === 'exchange');
-        if (!fulfillmentAction) {
-            throw new Error('No exchange action found');
-        }
-        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            unsignedFulfillmentTransaction: fulfillmentTransaction,
-        };
-    }
-    async cancelOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const cancellationTransaction = await this.seaport.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction);
-    }
-    async mapImmutableOrderToSeaportOrderComponents(order) {
-        const counterForOfferer = await this.seaport.getCounter(order.account_address);
-        return mapImmutableOrderToSeaportOrderComponents(order, counterForOfferer.toString(), this.zoneContractAddress);
-    }
-    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        return this.seaport.createOrder({
-            allowPartialFills: false,
-            offer: [
-                {
-                    itemType: constants.ItemType.ERC721,
-                    token: listingItem.contractAddress,
-                    identifier: listingItem.tokenId,
-                },
-            ],
-            consideration: [
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: considerationItem.amount,
-                    recipient: offerer,
-                },
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: royaltyInfo.amountRequired,
-                    recipient: royaltyInfo.recipient,
-                },
-            ],
-            startTime: (orderStart.getTime() / 1000).toFixed(0),
-            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
-            zone: this.zoneContractAddress,
-            restrictedByZone: true,
-        }, offerer);
-    }
-    async getTypedDataFromOrderComponents(orderComponents) {
-        const { chainId } = await this.provider.getNetwork();
-        const domainData = {
-            name: constants.SEAPORT_CONTRACT_NAME,
-            version: constants.SEAPORT_CONTRACT_VERSION_V1_4,
-            chainId,
-            verifyingContract: this.seaportContractAddress,
-        };
-        return {
-            domain: domainData,
-            types: constants.EIP_712_ORDER_TYPE,
-            value: orderComponents,
-        };
-    }
+async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
-class SeaportFactory {
-    seaportContractAddress;
-    zoneContractAddress;
-    provider;
-    seaport;
-    constructor(seaportContractAddress, zoneContractAddress, provider) {
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-        this.provider = provider;
-        this.seaport = new seaportJs.Seaport(provider, {
-            seaportVersion: '1.4',
-            balanceAndApprovalChecksOnOrderCreation: true,
-            overrides: {
-                contractAddress: seaportContractAddress,
-            },
-        });
-    }
-    create() {
-        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
-    }
+async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
-/**
- * zkEVM orderbook SDK
- * @constructor
- * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
- */
-class Orderbook {
-    config;
-    apiClient;
-    seaport;
-    constructor(config) {
-        this.config = config;
-        // TODO: Move endpoint lookup to a map based on env. Just using override to get dev started
-        const apiEndpoint = config.overrides?.apiEndpoint;
-        if (!apiEndpoint) {
-            throw new Error('API endpoint must be provided as an override');
-        }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainId = config.overrides?.chainId;
-        if (!chainId) {
-            throw new Error('ChainID must be provided as an override');
-        }
-        this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainId).create();
-        this.seaport = new SeaportFactory(this.config.seaportContractAddress, this.config.zoneContractAddress, this.config.provider).create();
-    }
-    /**
-     * Get an order by ID
-     * @param {string} orderId - The orderId to find.
-     * @return {Order} The returned order.
-     */
-    getOrder(orderId) {
-        return this.apiClient.getOrder(orderId);
-    }
-    /**
-     * Get required transactions and messages for signing prior to creating a listing
-     * through the createOrder method
-     * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
-     * @return {PrepareListingResponse} PrepareListingResponse includes
-     * the unsigned approval transaction, the typed order message for signing and
-     * the order components that can be submitted to `createOrder` with a signature.
-     */
-    async prepareListing({ offerer, listingItem, considerationItem, orderExpiry, }) {
-        const erc721 = new ERC721Factory(listingItem.contractAddress, this.config.provider).create();
-        const royaltyInfo = await erc721.royaltyInfo(listingItem.tokenId, considerationItem.amount);
-        return this.seaport.prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, 
-        // Default order start to now
-        new Date(), 
-        // Default order expiry to 2 years from now
-        orderExpiry || new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 2));
-    }
-    /**
-     * Create an order
-     * @param {CreateOrderParams} createOrderParams - create an order with the given params.
-     * @return {Order} The order created in the Immutable services.
-     */
-    createOrder(createOrderParams) {
-        return this.apiClient.createOrder(createOrderParams);
-    }
-    /**
-     * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
-     * transaction exists it must be signed and submitted to the chain before the fulfilment
-     * transaction can be submitted or it will be reverted.
-     * @param {string} orderId - The orderId to fulfil.
-     * @param {string} fulfillerAddress - The address of the account fulfilling the order.
-     * @return {FulfilOrderResponse} Approval and fulfilment transactions.
-     */
-    async fulfillOrder(orderId, fulfillerAddress) {
-        const order = await this.apiClient.getOrder(orderId);
-        if (order.status !== Order.status.ACTIVE) {
-            throw new Error(`Cannot fulfil order that is not active. Current status: ${order.status}`);
-        }
-        return this.seaport.fulfilOrder(order, fulfillerAddress);
-    }
-    /**
-     * Get an unsigned cancel order transaction. Orders can only be cancelled by
-     * the account that created them.
-     * @param {string} orderId - The orderId to cancel.
-     * @param {string} accountAddress - The address of the account cancelling the order.
-     * @return {CancelOrderResponse} The unsigned cancel order transaction
-     */
-    async cancelOrder(orderId, accountAddress) {
-        const order = await this.apiClient.getOrder(orderId);
-        if (order.status !== Order.status.ACTIVE
-            && order.status !== Order.status.INACTIVE
-            && order.status !== Order.status.PENDING) {
-            throw new Error(`Cannot cancel order with status ${order.status}`);
-        }
-        if (order.account_address !== accountAddress.toLowerCase()) {
-            throw new Error(`Only account ${order.account_address} can cancel order ${orderId}`);
-        }
-        const cancelOrderTransaction = await this.seaport.cancelOrder(order, accountAddress);
-        return { unsignedCancelOrderTransaction: cancelOrderTransaction };
+async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
+    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
-const module$1 = 'orderbook';
-
-function isChainValid(chainID, config) {
-    return chainID === config.ethConfiguration.chainID;
+async function prepareWithdrawal({ signers, withdrawal, config, }) {
+    return prepareWithdrawalAction({
+        signers,
+        config: config.immutableXConfig,
+        ...withdrawal,
+    });
 }
-async function validateChain(signer, config) {
-    const chainID = await signer.getChainId();
-    if (!isChainValid(chainID, config)) {
-        throw new Error('The wallet used for this operation is not connected to the correct network.');
+// TODO: remove once fixed
+// eslint-disable-next-line consistent-return
+async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
+    // TODO: please add a reasonable default here
+    // eslint-disable-next-line default-case
+    switch (token.type) {
+        case 'ETH':
+            return completeEthWithdrawalAction({ ethSigner, starkPublicKey, config });
+        case 'ERC20':
+            return completeERC20WithdrawalAction({
+                ethSigner,
+                starkPublicKey,
+                token,
+                config,
+            });
+        case 'ERC721':
+            return completeERC721WithdrawalAction({
+                ethSigner,
+                starkPublicKey,
+                token,
+                config,
+            });
     }
 }
 
-async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
-    const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
-    const signableResult = await transfersApi.getSignableTransferV1({
-        getSignableTransferRequest: {
-            sender: ethAddress,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
+    const tradesApi = new coreSdk.TradesApi(config.immutableXConfig.apiConfiguration);
+    const signableResult = await tradesApi.getSignableTrade({
+        getSignableTradeRequest: {
+            user: ethAddress,
+            order_id: request.order_id,
+            fees: request.fees,
         },
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
     const ethSignature = await signRaw(signableMessage, ethSigner);
     const starkSignature = await starkSigner.signMessage(payloadHash);
-    const transferSigningParams = {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        sender_stark_key: signableResult.data.sender_stark_key,
-        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 response = await transfersApi.createTransferV1({
-        createTransferRequest: transferSigningParams,
+    const createTradeResponse = await tradesApi.createTrade({
+        createTradeRequest: {
+            amount_buy: signableResult.data.amount_buy,
+            amount_sell: signableResult.data.amount_sell,
+            asset_id_buy: signableResult.data.asset_id_buy,
+            asset_id_sell: signableResult.data.asset_id_sell,
+            expiration_timestamp: signableResult.data.expiration_timestamp,
+            fee_info: signableResult.data.fee_info,
+            fees: request.fees,
+            include_fees: true,
+            nonce: signableResult.data.nonce,
+            order_id: request.order_id,
+            stark_key: signableResult.data.stark_key,
+            vault_id_buy: signableResult.data.vault_id_buy,
+            vault_id_sell: signableResult.data.vault_id_sell,
+            stark_signature: starkSignature,
+        },
         xImxEthAddress: ethAddress,
         xImxEthSignature: ethSignature,
     });
-    return {
-        sent_signature: response?.data.sent_signature,
-        status: response?.data.status?.toString(),
-        time: response?.data.time,
-        transfer_id: response?.data.transfer_id,
-    };
+    return createTradeResponse.data;
 }
-async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+
+async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
-    const signableRequests = request.map((nftTransfer) => ({
-        amount: '1',
-        token: convertToSignableToken({
-            type: 'ERC721',
-            tokenId: nftTransfer.tokenId,
-            tokenAddress: nftTransfer.tokenAddress,
-        }),
-        receiver: nftTransfer.receiver,
-    }));
-    const signableResult = await transfersApi.getSignableTransfer({
-        getSignableTransferRequestV2: {
-            sender_ether_key: ethAddress,
-            signable_requests: signableRequests,
+    const user = await ethSigner.getAddress();
+    const data = {
+        decimals: 18,
+    };
+    const amount = units.parseUnits(deposit.amount, 'wei');
+    const imxConfig = config.immutableXConfig;
+    const depositsApi = new coreSdk.DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
         },
-    });
-    const signableMessage = signableResult.data.signable_message;
-    if (signableMessage === undefined) {
-        throw new Error('Invalid response from Signable registration offchain');
-    }
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const requests = [];
-    for (const resp of signableResult.data.signable_responses) {
-        // TODO: remove once fixed
-        // eslint-disable-next-line no-await-in-loop
-        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
-        const req = {
-            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,
-        };
-        requests.push(req);
-    }
-    // TODO: throw error on missing payload hash?
-    const transferSigningParams = {
-        sender_stark_key: signableResult.data.sender_stark_key,
-        requests,
+        amount: amount.toString(),
     };
-    const response = await transfersApi.createTransfer({
-        createTransferRequestV2: transferSigningParams,
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
     });
-    return {
-        transfer_ids: response?.data.transfer_ids,
-    };
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
+    }
+    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
 }
 
-async function createOrder({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
-    const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
-    const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
-    const getSignableOrderRequest = {
-        user: ethAddress,
-        amount_buy: amountBuy,
-        token_buy: convertToSignableToken(request.buy),
-        amount_sell: amountSell,
-        token_sell: convertToSignableToken(request.sell),
-        fees: request.fees,
-        expiration_timestamp: request.expiration_timestamp,
+async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
+    const user = await ethSigner.getAddress();
+    const tokensApi = new coreSdk.TokensApi(apiConfiguration);
+    const depositsApi = new coreSdk.DepositsApi(apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(apiConfiguration);
+    // Get decimals for this specific ERC20
+    const token = await tokensApi.getToken({ address: deposit.tokenAddress });
+    // TODO: remove once fixed
+    // eslint-disable-next-line radix
+    const decimals = parseInt(token.data.decimals);
+    const data = {
+        decimals,
+        token_address: deposit.tokenAddress,
     };
-    const getSignableOrderResponse = await ordersApi.getSignableOrder({
-        getSignableOrderRequestV3: getSignableOrderRequest,
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const resp = getSignableOrderResponse.data;
-    const orderParams = {
-        createOrderRequest: {
-            amount_buy: resp.amount_buy,
-            amount_sell: resp.amount_sell,
-            asset_id_buy: resp.asset_id_buy,
-            asset_id_sell: resp.asset_id_sell,
-            expiration_timestamp: resp.expiration_timestamp,
-            include_fees: true,
-            fees: request.fees,
-            nonce: resp.nonce,
-            stark_key: resp.stark_key,
-            stark_signature: starkSignature,
-            vault_id_buy: resp.vault_id_buy,
-            vault_id_sell: resp.vault_id_sell,
+    const amount = units.parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
+    // Approve whether an amount of token from an account can be spent by a third-party account
+    const tokenContract = coreSdk.Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
+    const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
+    await ethSigner.sendTransaction(approveTransaction);
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
         },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    };
-    const createOrderResponse = await ordersApi.createOrder(orderParams);
-    return {
-        ...createOrderResponse.data,
+        amount: amount.toString(),
     };
-}
-async function cancelOrder({ signers, request, config, }) {
-    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
-    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
-        getSignableCancelOrderRequest: {
-            order_id: request.order_id,
-        },
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
     });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const cancelOrderResponse = await ordersApi.cancelOrder({
-        id: request.order_id.toString(),
-        cancelOrderRequest: {
-            order_id: request.order_id,
-            stark_signature: starkSignature,
+    // Perform encoding on asset details to get an assetType (required for stark contract request)
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+                data: {
+                    token_address: deposit.tokenAddress,
+                },
+            },
         },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
     });
-    return {
-        order_id: cancelOrderResponse.data.order_id,
-        status: cancelOrderResponse.data.status,
-    };
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const quantizedAmount = bignumber.BigNumber.from(signableDepositResult.data.amount);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
+    }
+    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
 }
 
-async function registerOffchain(signers, config) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
-    const userAddress = await signers.ethSigner.getAddress();
-    const starkPublicKey = await signers.starkSigner.getAddress();
-    const signableResult = await usersApi.getSignableRegistrationOffchain({
-        getSignableRegistrationRequest: {
-            ether_key: userAddress,
-            stark_key: starkPublicKey,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const registeredUser = await usersApi.registerUser({
-        registerUserRequest: {
-            eth_signature: ethSignature,
-            ether_key: userAddress,
-            stark_signature: starkSignature,
-            stark_key: starkPublicKey,
-        },
-    });
-    return registeredUser.data;
+async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
+async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
-    const registrationContract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    try {
-        return await registrationContract.isRegistered(starkPublicKey);
-    }
-    catch (ex) {
-        if (ex.reason === 'USER_UNREGISTERED') {
-            return false;
-        }
-        throw ex;
-    }
-}
-async function getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi) {
-    const response = await usersApi.getSignableRegistration({
-        getSignableRegistrationRequest: {
-            ether_key: etherKey,
-            stark_key: starkPublicKey,
-        },
-    });
-    return {
-        operator_signature: response.data.operator_signature,
-        payload_hash: response.data.payload_hash,
+    const user = await ethSigner.getAddress();
+    const { immutableXConfig } = config;
+    const depositsApi = new coreSdk.DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(immutableXConfig.apiConfiguration);
+    const data = {
+        token_address: deposit.tokenAddress,
+        token_id: deposit.tokenId,
     };
-}
-
-const assertIsDefined = (value) => {
-    if (value !== undefined)
-        return value;
-    throw new Error('undefined field exception');
-};
-async function prepareWithdrawalAction(params) {
-    const { signers: { ethSigner, starkSigner }, type, config, } = params;
-    await validateChain(ethSigner, params.config);
-    const withdrawalsApi = new coreSdk.WithdrawalsApi(config.apiConfiguration);
-    const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
-    const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawal({
-        getSignableWithdrawalRequest: {
-            user: await ethSigner.getAddress(),
-            token: convertToSignableToken(params),
-            amount: withdrawalAmount,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
-    const starkSignature = await starkSigner.signMessage(payloadHash);
-    const { ethAddress, ethSignature } = await signMessage(signableMessage, ethSigner);
-    const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
-        createWithdrawalRequest: {
-            stark_key: assertIsDefined(signableWithdrawalResult.data.stark_key),
-            amount: withdrawalAmount,
-            asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
-            vault_id: assertIsDefined(signableWithdrawalResult.data.vault_id),
-            nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
-            stark_signature: starkSignature,
+    const amount = '1';
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
         },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
     });
-    return prepareWithdrawalResponse.data;
-}
-
-async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
-    const encodingApi = new coreSdk.EncodingApi(config.apiConfiguration);
-    const result = await encodingApi.encodeAsset({
-        assetType,
+    // Perform encoding on asset details to get an assetType (required for stark contract request)
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
         encodeAssetRequest: {
             token: {
-                type: tokenType,
-                ...(tokenData && { data: tokenData }),
+                type: deposit.type,
+                data: {
+                    token_address: deposit.tokenAddress,
+                    token_id: deposit.tokenId,
+                },
             },
         },
     });
-    return result.data;
-}
-
-async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
-    const etherKey = await ethSigner.getAddress();
-    const imxConfig = config.immutableXConfig;
-    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
-        token_address: token.tokenAddress,
-    });
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC20({
-            ethSigner,
-            assetType: assetType.asset_type,
-            starkPublicKey,
-            config,
-        });
-    }
-    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-}
-
-async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-function getMintingBlob(token) {
-    const { id } = token.data;
-    const blueprint = token.data.blueprint || '';
-    return encUtils__namespace.sanitizeHex(encUtils__namespace.utf8ToHex(`{${id}}:{${blueprint}}`));
-}
-async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
-        id: token.data.id,
-        token_address: token.data.tokenAddress,
-        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
-    });
-    const mintingBlob = getMintingBlob(token);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
-    }
-    return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
-}
-async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
-        token_id: token.tokenId,
-        token_address: token.tokenAddress,
-    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
+    // Approve whether an amount of token from an account can be spent by a third-party account
+    const tokenContract = coreSdk.Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
+    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
+    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
+    if (!isApprovedForAll) {
+        await tokenContract.setApprovalForAll(operator, true);
     }
-    return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
-}
-async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { tokenAddress } = token;
-    const { tokenId } = token;
-    const imxConfig = config.immutableXConfig;
-    const mintsApi = new coreSdk.MintsApi(imxConfig.apiConfiguration);
-    return await mintsApi
-        .getMintableTokenDetailsByClientTokenId({
-        tokenAddress,
-        tokenId,
-    })
-        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
-        type: 'ERC721',
-        data: {
-            id: tokenId,
-            tokenAddress,
-            blueprint: mintableToken.data.blueprint,
-        },
-    }, config))
-        .catch((error) => {
-        if (error.response?.status === 404) {
-            // token is already minted on L1
-            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
-        }
-        throw error; // unable to recover from any other kind of error
-    });
-}
-
-async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
-        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+        const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
+        const coreContract = coreSdk.Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
+        // Note: proxy registration contract registerAndDepositNft method is not used as
+        // it currently fails erc721 transfer ownership check
+        await coreContract.registerUser(user, starkPublicKey, signableResult.operator_signature);
     }
-    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
 }
 
-async function prepareWithdrawal({ signers, withdrawal, config, }) {
-    return prepareWithdrawalAction({
-        signers,
-        config: config.immutableXConfig,
-        ...withdrawal,
-    });
-}
-// TODO: remove once fixed
-// eslint-disable-next-line consistent-return
-async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
+// TODO: remove once fixed deposit variable shadowing
+// eslint-disable-next-line consistent-return, @typescript-eslint/no-shadow
+async function deposit({ signers, deposit, config }) {
     // TODO: please add a reasonable default here
     // eslint-disable-next-line default-case
-    switch (token.type) {
+    switch (deposit.type) {
         case 'ETH':
-            return completeEthWithdrawalAction({ ethSigner, starkPublicKey, config });
-        case 'ERC20':
-            return completeERC20WithdrawalAction({
-                ethSigner,
-                starkPublicKey,
-                token,
-                config,
-            });
-        case 'ERC721':
-            return completeERC721WithdrawalAction({
-                ethSigner,
-                starkPublicKey,
-                token,
-                config,
-            });
-    }
-}
-
-async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new coreSdk.TradesApi(config.immutableXConfig.apiConfiguration);
-    const signableResult = await tradesApi.getSignableTrade({
-        getSignableTradeRequest: {
-            user: ethAddress,
-            order_id: request.order_id,
-            fees: request.fees,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkSigner.signMessage(payloadHash);
-    const createTradeResponse = await tradesApi.createTrade({
-        createTradeRequest: {
-            amount_buy: signableResult.data.amount_buy,
-            amount_sell: signableResult.data.amount_sell,
-            asset_id_buy: signableResult.data.asset_id_buy,
-            asset_id_sell: signableResult.data.asset_id_sell,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            fee_info: signableResult.data.fee_info,
-            fees: request.fees,
-            include_fees: true,
-            nonce: signableResult.data.nonce,
-            order_id: request.order_id,
-            stark_key: signableResult.data.stark_key,
-            vault_id_buy: signableResult.data.vault_id_buy,
-            vault_id_sell: signableResult.data.vault_id_sell,
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return createTradeResponse.data;
-}
-
-async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function depositEth({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const data = {
-        decimals: 18,
-    };
-    const amount = units.parseUnits(deposit.amount, 'wei');
-    const imxConfig = config.immutableXConfig;
-    const depositsApi = new coreSdk.DepositsApi(imxConfig.apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(imxConfig.apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
-    }
-    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
-}
-
-async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
-    const user = await ethSigner.getAddress();
-    const tokensApi = new coreSdk.TokensApi(apiConfiguration);
-    const depositsApi = new coreSdk.DepositsApi(apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(apiConfiguration);
-    // Get decimals for this specific ERC20
-    const token = await tokensApi.getToken({ address: deposit.tokenAddress });
-    // TODO: remove once fixed
-    // eslint-disable-next-line radix
-    const decimals = parseInt(token.data.decimals);
-    const data = {
-        decimals,
-        token_address: deposit.tokenAddress,
-    };
-    const amount = units.parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = coreSdk.Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
-    const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
-    await ethSigner.sendTransaction(approveTransaction);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                },
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const quantizedAmount = bignumber.BigNumber.from(signableDepositResult.data.amount);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
-    }
-    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
-}
-
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const { immutableXConfig } = config;
-    const depositsApi = new coreSdk.DepositsApi(immutableXConfig.apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(immutableXConfig.apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(immutableXConfig.apiConfiguration);
-    const data = {
-        token_address: deposit.tokenAddress,
-        token_id: deposit.tokenId,
-    };
-    const amount = '1';
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                    token_id: deposit.tokenId,
-                },
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = coreSdk.Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
-    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
-    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
-    if (!isApprovedForAll) {
-        await tokenContract.setApprovalForAll(operator, true);
-    }
-    if (!isRegistered) {
-        const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
-        const coreContract = coreSdk.Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
-        // Note: proxy registration contract registerAndDepositNft method is not used as
-        // it currently fails erc721 transfer ownership check
-        await coreContract.registerUser(user, starkPublicKey, signableResult.operator_signature);
-    }
-    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
-}
-
-// TODO: remove once fixed deposit variable shadowing
-// eslint-disable-next-line consistent-return, @typescript-eslint/no-shadow
-async function deposit({ signers, deposit, config }) {
-    // TODO: please add a reasonable default here
-    // eslint-disable-next-line default-case
-    switch (deposit.type) {
-        case 'ETH':
-            return depositEth({ signers, deposit, config });
+            return depositEth({ signers, deposit, config });
         case 'ERC20':
             return depositERC20({ signers, deposit, config });
         case 'ERC721':
@@ -4052,1336 +2217,339 @@ async function exchangeTransfer({ signers, request, config, }) {
     return {
         sent_signature: response?.data.sent_signature,
         status: response?.data.status?.toString(),
-        time: response?.data.time,
-        transfer_id: response?.data.transfer_id,
-    };
-}
-
-class GenericIMXProvider {
-    config;
-    signers;
-    constructor(config, ethSigner, starkSigner) {
-        this.config = config;
-        this.signers = { ethSigner, starkSigner };
-    }
-    async getAddress() {
-        return await this.signers.ethSigner.getAddress();
-    }
-    registerOffchain() {
-        return registerOffchain(this.signers, this.config);
-    }
-    batchNftTransfer(request) {
-        return batchTransfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    cancelOrder(request) {
-        return cancelOrder({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    completeWithdrawal(starkPublicKey, token) {
-        return completeWithdrawal({
-            config: this.config,
-            signers: this.signers,
-            token,
-            starkPublicKey,
-        });
-    }
-    createOrder(request) {
-        return createOrder({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    createTrade(request) {
-        return createTrade({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    deposit(tokenAmount) {
-        return deposit({
-            signers: this.signers,
-            deposit: tokenAmount,
-            config: this.config,
-        });
-    }
-    exchangeTransfer(request) {
-        return exchangeTransfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    async isRegisteredOnchain() {
-        const starkPublicKey = await this.signers.starkSigner.getAddress();
-        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
-    }
-    prepareWithdrawal(request) {
-        return prepareWithdrawal({
-            signers: this.signers,
-            withdrawal: request,
-            config: this.config,
-        });
-    }
-    transfer(request) {
-        return transfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-}
-
-const WALLET_ACTION = {
-    // TODO: remove once fixed - consider using an enum
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    SWITCH_CHAIN: 'wallet_switchEthereumChain',
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    CONNECT: 'eth_requestAccounts',
-};
-function isRequestableProvider(provider) {
-    return !!provider?.request;
-}
-async function connectProvider(provider, chainID) {
-    await provider.request({ method: WALLET_ACTION.CONNECT });
-    if (chainID) {
-        await provider.request({
-            method: WALLET_ACTION.SWITCH_CHAIN,
-            params: [{ chainId: `0x${chainID.toString(16)}` }],
-        });
-    }
-}
-
-const ERRORS = {
-    // TODO: remove once fixed - consider using something in line with the naming convention
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
-};
-async function connect$1({ chainID, }) {
-    const provider = (await detectEthereumProvider());
-    if (!isRequestableProvider(provider)) {
-        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
-    }
-    await connectProvider(provider, chainID);
-    // NOTE: if we want to listen to Metamask events in the future, we can add a
-    // listener here.
-    return new ethers.ethers.providers.Web3Provider(provider);
-}
-
-const COMMUNICATION_TYPE = 'message';
-var RequestEventType;
-(function (RequestEventType) {
-    RequestEventType["GET_CONNECTION_REQUEST"] = "GET_CONNECTION_REQUEST";
-    RequestEventType["CONNECT_WALLET_REQUEST"] = "CONNECT_WALLET_REQUEST";
-    RequestEventType["SIGN_MESSAGE_REQUEST"] = "SIGN_MESSAGE_REQUEST";
-    RequestEventType["DISCONNECT_WALLET_REQUEST"] = "DISCONNECT_WALLET_REQUEST";
-})(RequestEventType || (RequestEventType = {}));
-var ResponseEventType;
-(function (ResponseEventType) {
-    ResponseEventType["CONNECT_WALLET_RESPONSE"] = "CONNECT_WALLET_RESPONSE";
-    ResponseEventType["SIGN_MESSAGE_RESPONSE"] = "SIGN_MESSAGE_RESPONSE";
-    ResponseEventType["GET_CONNECTION_RESPONSE"] = "GET_CONNECTION_RESPONSE";
-    ResponseEventType["DISCONNECT_WALLET_RESPONSE"] = "DISCONNECT_WALLET_RESPONSE";
-})(ResponseEventType || (ResponseEventType = {}));
-
-function postRequestMessage(iframe, payload) {
-    if (iframe && iframe.contentWindow) {
-        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
-    }
-}
-
-function messageResponseListener(iframe, event, eventType, callback) {
-    if (iframe && event.source !== iframe.contentWindow) {
-        return;
-    }
-    const l2WalletMessage = event.data;
-    if (l2WalletMessage.type !== eventType) {
-        return;
-    }
-    callback(l2WalletMessage.details);
-}
-
-class ImxSigner {
-    publicAddress;
-    iframe;
-    constructor(publicAddress, iframe) {
-        this.publicAddress = publicAddress;
-        this.iframe = iframe;
-    }
-    getAddress() {
-        return this.publicAddress;
-    }
-    signMessage(rawMessage) {
-        return new Promise((resolve, reject) => {
-            const listener = (event) => {
-                messageResponseListener(this.iframe, event, ResponseEventType.SIGN_MESSAGE_RESPONSE, (messageDetails) => {
-                    window.removeEventListener(COMMUNICATION_TYPE, listener);
-                    if (!messageDetails.success) {
-                        reject(new Error(messageDetails.error?.message));
-                    }
-                    resolve(messageDetails.data.signedMessage);
-                });
-            };
-            window.addEventListener(COMMUNICATION_TYPE, listener);
-            postRequestMessage(this.iframe, {
-                type: RequestEventType.SIGN_MESSAGE_REQUEST,
-                details: { starkPublicKey: this.publicAddress, message: rawMessage },
-            });
-        });
-    }
-    getIFrame() {
-        return this.iframe;
-    }
-}
-
-const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
-const IMX_WALLET_IFRAME_HOSTS = {
-    [exports.Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
-    [exports.Environment.PRODUCTION]: 'https://wallets.immutable.com',
-};
-const IMX_WALLET_IFRAME_STYLE = 'display: none;';
-function getIFrame() {
-    return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
-}
-async function setupIFrame(env) {
-    return new Promise((resolve) => {
-        const iframe = document.createElement('iframe');
-        iframe.setAttribute('id', IMX_WALLET_IFRAME_ID);
-        iframe.setAttribute('src', IMX_WALLET_IFRAME_HOSTS[env]);
-        iframe.setAttribute('style', IMX_WALLET_IFRAME_STYLE);
-        document.body.appendChild(iframe);
-        iframe.onload = () => resolve(iframe);
-    });
-}
-async function getOrSetupIFrame(env) {
-    const iframe = getIFrame();
-    if (iframe)
-        return iframe;
-    return await setupIFrame(env);
-}
-
-const DEFAULT_CONNECTION_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
-const CONNECTION_FAILED_ERROR = 'The L2 IMX Wallet connection has failed';
-async function connect(l1Provider, env) {
-    const l1Signer = l1Provider.getSigner();
-    const address = await l1Signer.getAddress();
-    const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
-    const iframe = await getOrSetupIFrame(env);
-    return new Promise((resolve, reject) => {
-        const listener = (event) => {
-            messageResponseListener(iframe, event, ResponseEventType.CONNECT_WALLET_RESPONSE, (messageDetails) => {
-                window.removeEventListener(COMMUNICATION_TYPE, listener);
-                if (!messageDetails.success) {
-                    reject(new Error(CONNECTION_FAILED_ERROR));
-                }
-                resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
-            });
-        };
-        window.addEventListener(COMMUNICATION_TYPE, listener);
-        postRequestMessage(iframe, {
-            type: RequestEventType.CONNECT_WALLET_REQUEST,
-            details: { ethAddress: address, signature },
-        });
-    });
-}
-async function disconnect(imxSigner) {
-    const iframe = imxSigner.getIFrame();
-    return new Promise((resolve, reject) => {
-        const listener = (event) => {
-            messageResponseListener(iframe, event, ResponseEventType.DISCONNECT_WALLET_RESPONSE, (messageDetails) => {
-                window.removeEventListener(COMMUNICATION_TYPE, listener);
-                if (!messageDetails.success && messageDetails.error) {
-                    reject(messageDetails.error);
-                }
-                iframe.remove();
-                resolve();
-            });
-        };
-        window.addEventListener(COMMUNICATION_TYPE, listener);
-        postRequestMessage(iframe, {
-            type: RequestEventType.DISCONNECT_WALLET_REQUEST,
-            details: { starkPublicKey: imxSigner.getAddress() },
-        });
-    });
-}
-
-var ProviderErrorType;
-(function (ProviderErrorType) {
-    ProviderErrorType["PROVIDER_CONNECTION_ERROR"] = "PROVIDER_CONNECTION_ERROR";
-    ProviderErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
-})(ProviderErrorType || (ProviderErrorType = {}));
-class ProviderError extends Error {
-    type;
-    constructor(message, type) {
-        super(message);
-        this.type = type;
-    }
-}
-const withProviderError = async (fn, customError) => {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
-        throw new ProviderError(errorMessage, customError.type);
-    }
-};
-
-class MetaMaskIMXProvider extends GenericIMXProvider {
-    static imxSigner;
-    static async connect(config) {
-        return await withProviderError(async () => {
-            const metaMaskProvider = await connect$1({
-                chainID: config.immutableXConfig.ethConfiguration.chainID,
-            });
-            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
-            return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
-        }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
-    }
-    static async disconnect() {
-        if (!this.imxSigner) {
-            throw new ProviderError('Attempted to disconnect from the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
-        }
-        return withProviderError(async () => {
-            await disconnect(this.imxSigner);
-        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
-    }
-    static async signMessage(message) {
-        if (!this.imxSigner) {
-            throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
-        }
-        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
-    }
-}
-
-class ProviderConfiguration {
-    immutableXConfig;
-    baseConfig;
-    constructor({ baseConfig, overrides }) {
-        this.baseConfig = baseConfig;
-        if (overrides) {
-            this.immutableXConfig = overrides.immutableXConfig;
-        }
-        else {
-            // TODO: remove once a sensible default is chosen
-            // eslint-disable-next-line default-case
-            switch (baseConfig.environment) {
-                case exports.Environment.SANDBOX: {
-                    this.immutableXConfig = coreSdk.Config.SANDBOX;
-                    break;
-                }
-                case exports.Environment.PRODUCTION: {
-                    this.immutableXConfig = coreSdk.Config.PRODUCTION;
-                    break;
-                }
-            }
-        }
-    }
-}
-
-function $parcel$interopDefault(a) {
-  return a && a.__esModule ? a.default : a;
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
 }
 
-const $762782b6c862d954$export$db5daa1b5156ccfe = [
-    {
-        constant: true,
-        inputs: [],
-        name: "name",
-        outputs: [
-            {
-                name: "",
-                type: "string"
-            }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: "decimals",
-        outputs: [
-            {
-                name: "",
-                type: "uint8"
-            }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                name: "_owner",
-                type: "address"
-            }
-        ],
-        name: "balanceOf",
-        outputs: [
-            {
-                name: "balance",
-                type: "uint256"
-            }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: "symbol",
-        outputs: [
-            {
-                name: "",
-                type: "string"
-            }
-        ],
-        payable: false,
-        type: "function"
+class GenericIMXProvider {
+    config;
+    signers;
+    constructor(config, ethSigner, starkSigner) {
+        this.config = config;
+        this.signers = { ethSigner, starkSigner };
     }
-];
-
-
-
-const $bc2bfebf768286d3$export$6a2ba3c3bd042990 = {
-    baseConfig: {
-        environment: (exports.Environment).SANDBOX
+    async getAddress() {
+        return await this.signers.ethSigner.getAddress();
     }
-};
-
-
-exports.ConnectionProviders = void 0;
-(function(ConnectionProviders) {
-    ConnectionProviders["METAMASK"] = "metamask";
-})(exports.ConnectionProviders || (exports.ConnectionProviders = {}));
-
-
-exports.ChainId = void 0;
-(function(ChainId) {
-    ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
-    ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
-    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13373] = "IMTBL_ZKEVM_DEVNET";
-    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13372] = "IMTBL_ZKEVM_TESTNET";
-    ChainId[ChainId["POLYGON_ZKEVM_TESTNET"] = 1442] = "POLYGON_ZKEVM_TESTNET";
-    ChainId[ChainId["POLYGON_ZKEVM"] = 137] = "POLYGON_ZKEVM";
-})(exports.ChainId || (exports.ChainId = {}));
-const $a47e48dd2c04791b$export$6f24f3cef7d501c4 = new Map([
-    [
-        exports.ChainId.ETHEREUM,
-        {
-            chainIdHex: "0x1",
-            chainName: "Ethereum",
-            rpcUrls: [
-                "https://mainnet.infura.io/v3/"
-            ],
-            nativeCurrency: {
-                name: "Ethereum",
-                symbol: "ETH",
-                decimals: 18
-            },
-            blockExplorerUrls: [
-                "https://etherscan.io/"
-            ]
-        }
-    ],
-    [
-        exports.ChainId.IMTBL_ZKEVM_TESTNET,
-        {
-            chainIdHex: "0x343C",
-            chainName: "Immutable zkEVM Testnet",
-            rpcUrls: [
-                "https://zkevm-rpc.sandbox.x.immutable.com"
-            ],
-            nativeCurrency: {
-                name: "IMX",
-                symbol: "IMX",
-                decimals: 18
-            }
-        }
-    ],
-    [
-        exports.ChainId.POLYGON_ZKEVM,
-        {
-            chainIdHex: "0x89",
-            chainName: "Polygon zkEVM",
-            rpcUrls: [
-                "https://polygon-rpc.com"
-            ],
-            nativeCurrency: {
-                name: "MATIC",
-                symbol: "MATIC",
-                decimals: 18
-            },
-            blockExplorerUrls: [
-                "https://polygonscan.com/"
-            ]
-        }
-    ]
-]);
-const $a47e48dd2c04791b$export$3e81fc0987227f10 = new Map([
-    [
-        exports.ChainId.SEPOLIA,
-        {
-            chainIdHex: "0xaa36a7",
-            chainName: "Sepolia",
-            rpcUrls: [
-                "https://sepolia.infura.io/v3/"
-            ],
-            nativeCurrency: {
-                name: "Sep Eth",
-                symbol: "ETH",
-                decimals: 18
-            },
-            blockExplorerUrls: [
-                "https://sepolia.etherscan.io/"
-            ]
-        }
-    ],
-    [
-        exports.ChainId.IMTBL_ZKEVM_DEVNET,
-        {
-            chainIdHex: "0x343D",
-            chainName: "Immutable zkEVM Devnet",
-            rpcUrls: [
-                "https://zkevm-rpc.dev.x.immutable.com/"
-            ],
-            nativeCurrency: {
-                name: "IMX",
-                symbol: "IMX",
-                decimals: 18
-            }
-        }
-    ],
-    [
-        exports.ChainId.POLYGON_ZKEVM_TESTNET,
-        {
-            chainIdHex: "0x5A2",
-            chainName: "Polygon zkEVM Testnet",
-            rpcUrls: [
-                "https://rpc.public.zkevm-test.net"
-            ],
-            nativeCurrency: {
-                name: "MATIC",
-                symbol: "MATIC",
-                decimals: 18
-            },
-            blockExplorerUrls: [
-                "https://testnet-zkevm.polygonscan.com"
-            ]
-        }
-    ]
-]);
-exports.NetworkFilterTypes = void 0;
-(function(NetworkFilterTypes) {
-    NetworkFilterTypes["ALL"] = "all";
-})(exports.NetworkFilterTypes || (exports.NetworkFilterTypes = {}));
-
-
-// TODO: fix circular dependency
-// eslint-disable-next-line import/no-cycle
-exports.TokenFilterTypes = void 0;
-(function(TokenFilterTypes) {
-    TokenFilterTypes["SWAP"] = "swap";
-    TokenFilterTypes["BRIDGE"] = "bridge";
-    TokenFilterTypes["ALL"] = "all";
-})(exports.TokenFilterTypes || (exports.TokenFilterTypes = {}));
-
-
-
-
-// TODO: fix circular dependency
-// eslint-disable-next-line import/no-cycle
-let $4f91c5f280efe242$export$35b06f0d33f57e26;
-(function(WalletAction) {
-    WalletAction["CHECK_CONNECTION"] = "eth_accounts";
-    WalletAction["CONNECT"] = "eth_requestAccounts";
-    WalletAction["ADD_NETWORK"] = "wallet_addEthereumChain";
-    WalletAction["SWITCH_NETWORK"] = "wallet_switchEthereumChain";
-})($4f91c5f280efe242$export$35b06f0d33f57e26 || ($4f91c5f280efe242$export$35b06f0d33f57e26 = {}));
-exports.WalletFilterTypes = void 0;
-(function(WalletFilterTypes) {
-    WalletFilterTypes["ALL"] = "all";
-    WalletFilterTypes["DESKTOP"] = "desktop";
-    WalletFilterTypes["MOBILE"] = "mobile";
-})(exports.WalletFilterTypes || (exports.WalletFilterTypes = {}));
-
-
-
-
-/**
- * The different types of errors that can be returned by the checkout process.
- */ exports.CheckoutErrorType = void 0;
-(function(CheckoutErrorType) {
-    CheckoutErrorType["PROVIDER_PREFERENCE_ERROR"] = "PROVIDER_PREFERENCE_ERROR";
-    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
-    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
-    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
-    CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
-    CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
-    CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_MISSING_ERROR"] = "PROVIDER_REQUEST_MISSING_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
-    CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
-    CheckoutErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
-})(exports.CheckoutErrorType || (exports.CheckoutErrorType = {}));
-class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
-    constructor(message, type, data){
-        super(message);
-        this.message = message;
-        this.type = type;
-        this.data = data;
+    registerOffchain() {
+        return registerOffchain(this.signers, this.config);
     }
-}
-let $a8bc256d81a5e2c1$export$a22d4e0719ee6def;
-(function(CheckoutInternalErrorType) {
-    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
-})($a8bc256d81a5e2c1$export$a22d4e0719ee6def || ($a8bc256d81a5e2c1$export$a22d4e0719ee6def = {}));
-const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
-    try {
-        return await fn();
-    } catch (error) {
-        const cause = `${error.message}` || "UnknownError";
-        const errorMessage = customError.message ? `[${customError.type}]:${customError.message}. Cause:${cause}` : `[${customError.type}] Cause:${cause}`;
-        if (error instanceof $a8bc256d81a5e2c1$export$b722478a3cbfa3bc) throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
-            ...customError.data,
-            innerErrorType: error.type,
-            ...error.data
-        });
-        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
-            ...customError.data
+    batchNftTransfer(request) {
+        return batchTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
     }
-};
-
-
-
-
-/* eslint-disable @typescript-eslint/no-explicit-any */ 
-
-/* eslint-disable @typescript-eslint/no-explicit-any */ 
-
-
-
-async function $c99672cf2294e839$var$getMetaMaskProvider() {
-    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>await (detectEthereumProvider)(), {
-        type: (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR
-    });
-    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR);
-    return new (providers.Web3Provider)(provider);
-}
-async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
-    let web3Provider = null;
-    switch(providerPreference){
-        case (exports.ConnectionProviders).METAMASK:
-            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
-            break;
-        default:
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
+    cancelOrder(request) {
+        return cancelOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    return web3Provider;
-}
-async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
-    const provider = await $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference);
-    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
-        details: `Unsupported provider for ${providerPreference}`
-    });
-    let accounts = [];
-    try {
-        accounts = await provider.provider.request({
-            method: (0, $4f91c5f280efe242$export$35b06f0d33f57e26).CHECK_CONNECTION,
-            params: []
+    completeWithdrawal(starkPublicKey, token) {
+        return completeWithdrawal({
+            config: this.config,
+            signers: this.signers,
+            token,
+            starkPublicKey,
         });
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Check wallet connection request failed", (exports.CheckoutErrorType).PROVIDER_REQUEST_FAILED_ERROR, {
-            rpcMethod: ($4f91c5f280efe242$export$35b06f0d33f57e26).CHECK_CONNECTION
+    }
+    createOrder(request) {
+        return createOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
     }
-    // accounts[0] will have the active account if connected.
-    return {
-        isConnected: accounts && accounts.length > 0,
-        walletAddress: accounts[0] ?? ""
-    };
-}
-async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
-    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
-    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
-            details: `Unsupported provider for ${params.providerPreference}`
+    createTrade(request) {
+        return createTrade({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
-        await web3Provider.provider.request({
-            method: ($4f91c5f280efe242$export$35b06f0d33f57e26).CONNECT,
-            params: []
+    }
+    deposit(tokenAmount) {
+        return deposit({
+            signers: this.signers,
+            deposit: tokenAmount,
+            config: this.config,
         });
-    }, {
-        type: (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR
-    });
-    return web3Provider;
-}
-
-
-var $497c134ecbc8a50f$exports = {};
-$497c134ecbc8a50f$exports = JSON.parse('[{"chainId":1},{"chainId":11155111},{"chainId":13372},{"chainId":13373},{"chainId":1442},{"chainId":137}]');
-
-
-const $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE = 4902; // error code (MetaMask)
-// these functions should not be exported. These functions should be used as part of an exported function e.g switchWalletNetwork() above.
-// make sure to check if(provider.provider?.request) in the exported function and throw an error
-// eslint-disable-next-line consistent-return
-async function $de192de6ef100f9f$var$switchNetworkInWallet(networkMap, provider, chainId) {
-    if (provider.provider?.request) return await provider.provider.request({
-        method: ($4f91c5f280efe242$export$35b06f0d33f57e26).SWITCH_NETWORK,
-        params: [
-            {
-                chainId: networkMap.get(chainId)?.chainIdHex
-            }
-        ]
-    });
-}
-// TODO: Should these functions always return something?
-// eslint-disable-next-line consistent-return
-async function $de192de6ef100f9f$var$addNetworkToWallet(networkMap, provider, chainId) {
-    if (provider.provider?.request) {
-        const networkDetails = networkMap.get(chainId);
-        const addNetwork = {
-            chainId: networkDetails?.chainIdHex,
-            chainName: networkDetails?.chainName,
-            rpcUrls: networkDetails?.rpcUrls,
-            nativeCurrency: networkDetails?.nativeCurrency,
-            blockExplorerUrls: networkDetails?.blockExplorerUrls
-        };
-        return await provider.provider.request({
-            method: ($4f91c5f280efe242$export$35b06f0d33f57e26).ADD_NETWORK,
-            params: [
-                addNetwork
-            ]
+    }
+    exchangeTransfer(request) {
+        return exchangeTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
     }
-}
-async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(config, provider) {
-    const { networkMap: networkMap  } = config;
-    return ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const network = await provider.getNetwork();
-        if (!Array.from(networkMap.keys()).includes(network.chainId)) // return empty details
-        return {
-            chainId: network.chainId,
-            name: network.name,
-            isSupported: false
-        };
-        const chainIdNetworkInfo = networkMap.get(network.chainId);
-        return {
-            name: chainIdNetworkInfo.chainName,
-            chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
-            nativeCurrency: chainIdNetworkInfo.nativeCurrency,
-            isSupported: true
-        };
-    }, {
-        type: (exports.CheckoutErrorType).GET_NETWORK_INFO_ERROR
-    });
-}
-async function $de192de6ef100f9f$export$b827d9418aeb5dbd(config, providerPreference, provider, chainId) {
-    let currentProvider = provider;
-    const { networkMap: networkMap  } = config;
-    if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
-    if (!currentProvider || !currentProvider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
-        details: "Unsupported provider"
-    });
-    // WT-1146 - Refer to the README in this folder for explantion on the switch network flow
-    try {
-        await $de192de6ef100f9f$var$switchNetworkInWallet(networkMap, currentProvider, chainId);
-    } catch (err) {
-        if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
-            await $de192de6ef100f9f$var$addNetworkToWallet(networkMap, currentProvider, chainId);
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        } catch (err) {
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled add network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
-        }
-        else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
+    async isRegisteredOnchain() {
+        const starkPublicKey = await this.signers.starkSigner.getAddress();
+        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
     }
-    currentProvider = await ($c99672cf2294e839$export$fba2f6c3656e07c1)({
-        providerPreference: providerPreference
-    });
-    if ((await currentProvider.getNetwork()).chainId !== chainId) // user didn't actually switch
-    throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
-    // we can assume that if the above succeeds then user has successfully
-    // switched to the network specified
-    const newNetwork = networkMap.get(chainId);
-    return {
-        network: {
-            name: newNetwork?.chainName,
-            chainId: parseInt(newNetwork?.chainIdHex ?? "", 16),
-            nativeCurrency: newNetwork?.nativeCurrency
-        },
-        provider: currentProvider
-    };
-}
-async function $de192de6ef100f9f$export$3043f6442a9ef563(config, { type: type = (exports.NetworkFilterTypes).ALL , exclude: exclude  }) {
-    const { networkMap: networkMap  } = config;
-    const list = ((/*@__PURE__*/$parcel$interopDefault($497c134ecbc8a50f$exports))).filter((network)=>{
-        const allowAllTokens = type === (exports.NetworkFilterTypes).ALL;
-        const networkNotExcluded = !(exclude || []).map((exc)=>exc.chainId).includes(network.chainId);
-        return allowAllTokens && networkNotExcluded;
-    });
-    const allowedNetworks = [];
-    list.forEach((element)=>{
-        const newNetwork = networkMap.get(element.chainId);
-        if (newNetwork) allowedNetworks.push({
-            name: newNetwork.chainName,
-            chainId: parseInt(newNetwork.chainIdHex, 16),
-            nativeCurrency: newNetwork.nativeCurrency,
-            isSupported: true
+    prepareWithdrawal(request) {
+        return prepareWithdrawal({
+            signers: this.signers,
+            withdrawal: request,
+            config: this.config,
         });
-    });
-    return {
-        networks: allowedNetworks
-    };
+    }
+    transfer(request) {
+        return transfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
+    }
 }
 
-
-
-
-
-var $cda6003506e4182e$exports = {};
-$cda6003506e4182e$exports = JSON.parse("[{\"chainId\":13373,\"name\":\"IMX\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":13373,\"name\":\"FUN token\",\"address\":\"0xd8f1D29a1572FbCeF0B0C9541E50637Ad8804F21\",\"symbol\":\"FUN\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":13373,\"name\":\"USDC\",\"address\":\"0x5893A5c7bc615Dfd36D7383366d00FFFca5f7178\",\"symbol\":\"USDC\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":13373,\"name\":\"WETH\",\"address\":\"0xD6d9321DCC42377C1fa8cFec665182c463b2392C\",\"symbol\":\"WETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":1,\"name\":\"Ethereum\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF\",\"chainId\":1,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":11155111,\"name\":\"Sep Eth\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":11155111,\"name\":\"Immutable Test token\",\"address\":\"0x40cAdc2BC5d25B9c669B8E09c68eCcb9B80873f7\",\"symbol\":\"TEST\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"chainId\":1442,\"name\":\"WETH\",\"address\":\"0x4F062A3EAeC3730560aB89b5CE5aC0ab2C5517aE\",\"symbol\":\"WETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x72958b06abdF2701AcE6ceb3cE0B8B1CE11E0851\",\"chainId\":1442,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]}]");
-
-
-const $efe60cea83bfc4e8$var$filterTokenList = ({ type: type , chainId: chainId , exclude: exclude  })=>((/*@__PURE__*/$parcel$interopDefault($cda6003506e4182e$exports))).filter((token)=>{
-        const skipChainIdCheck = !chainId;
-        const chainIdMatches = token.chainId === chainId;
-        const tokenNotExcluded = !exclude?.map((excludeToken)=>excludeToken.address).includes(token.address || "");
-        const allowAllTokens = type === (exports.TokenFilterTypes).ALL;
-        const tokenAllowedForType = token.tokenFeatures.includes(type);
-        return (skipChainIdCheck || chainIdMatches) && tokenNotExcluded && (allowAllTokens || tokenAllowedForType);
-    });
-const $efe60cea83bfc4e8$export$473cec51305fdae8 = async ({ type: type = (exports.TokenFilterTypes).ALL , chainId: chainId , exclude: exclude  })=>{
-    const filteredTokenList = $efe60cea83bfc4e8$var$filterTokenList({
-        type: type,
-        chainId: chainId,
-        exclude: exclude
-    }).map((token)=>({
-            name: token.name,
-            symbol: token.symbol,
-            decimals: token.decimals,
-            address: token.address,
-            icon: token.icon
-        }));
-    return {
-        tokens: filteredTokenList
-    };
+const WALLET_ACTION = {
+    // TODO: remove once fixed - consider using an enum
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    SWITCH_CHAIN: 'wallet_switchEthereumChain',
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    CONNECT: 'eth_requestAccounts',
 };
-
-
-
-
-const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (config, provider, walletAddress)=>await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(config, provider);
-        if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR, {
-            chainName: networkInfo.name
-        });
-        const balance = await provider.getBalance(walletAddress);
-        return {
-            balance: balance,
-            formattedBalance: (ethers.utils).formatUnits(balance, networkInfo.nativeCurrency.decimals),
-            token: networkInfo.nativeCurrency
-        };
-    }, {
-        type: (exports.CheckoutErrorType).GET_BALANCE_ERROR
-    });
-async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, contractAddress) {
-    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const contract = new (ethers.Contract)(contractAddress, JSON.stringify(($762782b6c862d954$export$db5daa1b5156ccfe)), provider);
-        const name = await contract.name();
-        const symbol = await contract.symbol();
-        const balance = await contract.balanceOf(walletAddress);
-        const decimals = await contract.decimals();
-        const formattedBalance = (ethers.utils).formatUnits(balance, decimals);
-        return {
-            balance: balance,
-            formattedBalance: formattedBalance,
-            token: {
-                name: name,
-                symbol: symbol,
-                decimals: decimals,
-                address: contractAddress
-            }
-        };
-    }, {
-        type: (exports.CheckoutErrorType).GET_ERC20_BALANCE_ERROR
-    });
+function isRequestableProvider(provider) {
+    return !!provider?.request;
 }
-const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, provider, walletAddress, chainId)=>{
-    if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`ChainId ${chainId} is not supported`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
-    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR);
-    const tokenList = await ($efe60cea83bfc4e8$export$473cec51305fdae8)({
-        type: (exports.TokenFilterTypes).ALL,
-        chainId: chainId
-    });
-    const allBalancePromises = [];
-    allBalancePromises.push($1564e43dde50bb61$export$df96cd8d56be0ab1(config, provider, walletAddress));
-    tokenList.tokens.filter((token)=>token.address).forEach((token)=>allBalancePromises.push($1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, token.address ?? "")));
-    const balanceResults = await Promise.allSettled(allBalancePromises);
-    const getBalanceResults = balanceResults.filter((result)=>result.status === "fulfilled").map((fulfilledResult)=>fulfilledResult.value);
-    return {
-        balances: getBalanceResults
-    };
-};
-
-
-
-
-
-
-
-
-
-var $6f3c55a615003cbf$exports = {};
-$6f3c55a615003cbf$exports = JSON.parse('[{"connectionProvider":"metamask","icon":"some-icon-url","name":"MetaMask","description":"complete web3 wallet solution","platform":["desktop"]},{"connectionProvider":"passport","icon":"pp-icon","name":"Passport","description":"Web3 with your email!","platform":["mobile","desktop"]},{"connectionProvider":"gamestop","icon":"gme-icon","name":"GameStop","description":"Never stopping the game!","platform":["mobile"]}]');
-
-
-async function $5cdde2ffe6360fec$export$a822caa90d7eef09({ type: type = (exports.WalletFilterTypes).ALL , exclude: exclude  }) {
-    // todo:For async API call, use the CheckoutError with errorType:API_CALL_ERROR?? or any other
-    const filteredWalletsList = ((/*@__PURE__*/$parcel$interopDefault($6f3c55a615003cbf$exports))).filter((wallet)=>{
-        const walletNotExcluded = !exclude?.map((excludeWallet)=>excludeWallet.connectionProvider).includes(wallet.connectionProvider);
-        const allowAllWallets = type === (exports.WalletFilterTypes).ALL;
-        const walletsAllowedForType = wallet.platform.includes(type);
-        return walletNotExcluded && (allowAllWallets || walletsAllowedForType);
-    }).map((wallet)=>{
-        const { platform: platform , ...walletInfo } = wallet;
-        return walletInfo;
-    });
-    return {
-        wallets: filteredWalletsList
-    };
+async function connectProvider(provider, chainID) {
+    await provider.request({ method: WALLET_ACTION.CONNECT });
+    if (chainID) {
+        await provider.request({
+            method: WALLET_ACTION.SWITCH_CHAIN,
+            params: [{ chainId: `0x${chainID.toString(16)}` }],
+        });
+    }
 }
 
-
-
-
-
-
-const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (params)=>{
-    const { provider: provider , transaction: transaction  } = params;
-    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const transactionResponse = await provider.getSigner().sendTransaction(transaction);
-        return {
-            transactionResponse: transactionResponse
-        };
-    }, {
-        type: (exports.CheckoutErrorType).TRANSACTION_ERROR
-    });
+const ERRORS = {
+    // TODO: remove once fixed - consider using something in line with the naming convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
 };
+async function connect$1({ chainID, }) {
+    const provider = (await detectEthereumProvider());
+    if (!isRequestableProvider(provider)) {
+        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
+    }
+    await connectProvider(provider, chainID);
+    // NOTE: if we want to listen to Metamask events in the future, we can add a
+    // listener here.
+    return new ethers.ethers.providers.Web3Provider(provider);
+}
 
+const COMMUNICATION_TYPE = 'message';
+var RequestEventType;
+(function (RequestEventType) {
+    RequestEventType["GET_CONNECTION_REQUEST"] = "GET_CONNECTION_REQUEST";
+    RequestEventType["CONNECT_WALLET_REQUEST"] = "CONNECT_WALLET_REQUEST";
+    RequestEventType["SIGN_MESSAGE_REQUEST"] = "SIGN_MESSAGE_REQUEST";
+    RequestEventType["DISCONNECT_WALLET_REQUEST"] = "DISCONNECT_WALLET_REQUEST";
+})(RequestEventType || (RequestEventType = {}));
+var ResponseEventType;
+(function (ResponseEventType) {
+    ResponseEventType["CONNECT_WALLET_RESPONSE"] = "CONNECT_WALLET_RESPONSE";
+    ResponseEventType["SIGN_MESSAGE_RESPONSE"] = "SIGN_MESSAGE_RESPONSE";
+    ResponseEventType["GET_CONNECTION_RESPONSE"] = "GET_CONNECTION_RESPONSE";
+    ResponseEventType["DISCONNECT_WALLET_RESPONSE"] = "DISCONNECT_WALLET_RESPONSE";
+})(ResponseEventType || (ResponseEventType = {}));
 
-
-
-
-
-
-
-class $4013c5c91bb535f6$export$47a4ed4a38b9eecf extends Error {
-    constructor(message){
-        super(message);
-        this.message = message;
-    }
-}
-class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
-    constructor(config){
-        // validate input
-        if (!Object.values((exports.Environment)).includes(config.baseConfig.environment)) throw new $4013c5c91bb535f6$export$47a4ed4a38b9eecf("Invalid checkout configuration of environment");
-        this.environment = config.baseConfig.environment;
-        this.networkMap = config.baseConfig.environment === (exports.Environment).PRODUCTION ? ($a47e48dd2c04791b$export$6f24f3cef7d501c4) : ($a47e48dd2c04791b$export$3e81fc0987227f10);
+function postRequestMessage(iframe, payload) {
+    if (iframe && iframe.contentWindow) {
+        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
     }
 }
 
-
-
-
-class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
-    constructor(config = ($bc2bfebf768286d3$export$6a2ba3c3bd042990)){
-        this.config = new ($4013c5c91bb535f6$export$4823433c4a67bbc6)(config);
-    }
-    /**
-   * Check if a wallet is connected to the current application
-   * without requesting permission from the wallet and hence triggering a connect popup.
-   * @param {CheckConnectionParams} params - The necessary data required to verify a wallet connection status.
-   * @returns Wallet connection status details.
-   * @throws {@link ErrorType}
-   */ // eslint-disable-next-line class-methods-use-this
-    async checkIsWalletConnected(params) {
-        return $c99672cf2294e839$export$2d040992269b4717(params.providerPreference);
-    }
-    /**
-   * Establish a connection with a wallet provider such as MetaMask and returns the provider object and the current network details.
-   * @param {ConnectParams} params - The necessary data required to establish a connection with a wallet provider.
-   * @returns Wallet provider and current network information.
-   * @throws {@link ErrorType}
-   */ async connect(params) {
-        this.providerPreference = params.providerPreference;
-        const provider = await $c99672cf2294e839$export$fba2f6c3656e07c1(params);
-        const networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(this.config, provider);
-        return {
-            provider: provider,
-            network: networkInfo
-        };
-    }
-    /**
-   * Switch the currently connected wallet to a new network.
-   * @param {SwitchNetworkParams} params - The necessary data required to switch network.
-   * @returns The new network information.
-   * @throws {@link ErrorType}
-   */ async switchNetwork(params) {
-        if (!this.providerPreference) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("connect should be called before switchNetwork to set the provider preference", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
-        return await $de192de6ef100f9f$export$b827d9418aeb5dbd(this.config, this.providerPreference, params.provider, params.chainId);
-    }
-    /**
-   * Fetch the balance of the native token of the current connected network or,
-   * if a contract address is provided, it will return the balance of that ERC20 token. For example,
-   * if the wallet is connected to the Ethereum Mainnet then the function gets the wallet ETH L1 balance.
-   * @param {GetBalanceParams} params - The necessary data required to fetch the wallet balance.
-   * @returns Native token balance for the given wallet.
-   * @throws {@link ErrorType}
-   */ async getBalance(params) {
-        if (!params.contractAddress || params.contractAddress === "") return await $1564e43dde50bb61$export$df96cd8d56be0ab1(this.config, params.provider, params.walletAddress);
-        return await $1564e43dde50bb61$export$60e0fe116a0e6ed0(params.provider, params.walletAddress, params.contractAddress);
-    }
-    /**
-   * Fetch all available balances (ERC20 & Native) of the current connected network of the given wallet.
-   * It will loop through the list of allowed tokens and check for balance on each one.
-   * @param {GetAllBalancesParams} params - The necessary data required to fetch all the wallet balances.
-   * @returns List of tokens balance for the given wallet.
-   * @throws {@link ErrorType}
-   */ async getAllBalances(params) {
-        return $1564e43dde50bb61$export$fee49741664a4d7e(this.config, params.provider, params.walletAddress, params.chainId);
+function messageResponseListener(iframe, event, eventType, callback) {
+    if (iframe && event.source !== iframe.contentWindow) {
+        return;
     }
-    /**
-   * Fetch the list of available networks that a wallet can add or/and switch to.
-   * @param {GetNetworkAllowListParams} params - The necessary data required to fetch the list of available networks.
-   * @returns List of networks.
-   * @throws {@link ErrorType}
-   */ async getNetworkAllowList(params) {
-        return await $de192de6ef100f9f$export$3043f6442a9ef563(this.config, params);
+    const l2WalletMessage = event.data;
+    if (l2WalletMessage.type !== eventType) {
+        return;
     }
-    /**
-   * Get the list of tokens which are allowed to be used with the product.
-   * @param {GetTokenAllowListParams} params - The necessary data required to fetch the list of allowed tokens.
-   * @returns List of allowed tokens.
-   * @throws {@link ErrorType}
-   */ // eslint-disable-next-line class-methods-use-this
-    async getTokenAllowList(params) {
-        return await $efe60cea83bfc4e8$export$473cec51305fdae8(params);
+    callback(l2WalletMessage.details);
+}
+
+class ImxSigner {
+    publicAddress;
+    iframe;
+    constructor(publicAddress, iframe) {
+        this.publicAddress = publicAddress;
+        this.iframe = iframe;
     }
-    /**
-   * Fetch the list of wallets which are available to connect with.
-   * @param {GetWalletAllowListParams} params - The necessary data required to fetch the list of allowed wallets.
-   * @returns List of allowed wallets.
-   * @throws {@link ErrorType}
-   */ // eslint-disable-next-line class-methods-use-this
-    async getWalletAllowList(params) {
-        return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
+    getAddress() {
+        return this.publicAddress;
     }
-    /**
-   * Send a generic transaction to the provider.
-   * @param {SendTransactionParams} params - The necessary data required to send a transaction.
-   * @returns Transaction response.
-   * @throws {@link ErrorType}
-   * @remarks
-   * Further documenation can be found at [MetaMask | Sending Transactions](https://docs.metamask.io/guide/sending-transactions.html).
-   */ // eslint-disable-next-line class-methods-use-this
-    async sendTransaction(params) {
-        return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
+    signMessage(rawMessage) {
+        return new Promise((resolve, reject) => {
+            const listener = (event) => {
+                messageResponseListener(this.iframe, event, ResponseEventType.SIGN_MESSAGE_RESPONSE, (messageDetails) => {
+                    window.removeEventListener(COMMUNICATION_TYPE, listener);
+                    if (!messageDetails.success) {
+                        reject(new Error(messageDetails.error?.message));
+                    }
+                    resolve(messageDetails.data.signedMessage);
+                });
+            };
+            window.addEventListener(COMMUNICATION_TYPE, listener);
+            postRequestMessage(this.iframe, {
+                type: RequestEventType.SIGN_MESSAGE_REQUEST,
+                details: { starkPublicKey: this.publicAddress, message: rawMessage },
+            });
+        });
     }
-    /**
-   * Get network information about the currently selected network.
-   * @param {GetNetworkParams} params - The necessary data required to get the current network information.
-   * @returns Network details.
-   * @throws {@link ErrorType}
-   */ async getNetworkInfo(params) {
-        return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(this.config, params.provider);
+    getIFrame() {
+        return this.iframe;
     }
 }
 
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
+const IMX_WALLET_IFRAME_HOSTS = {
+    [exports.Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
+    [exports.Environment.PRODUCTION]: 'https://wallets.immutable.com',
+};
+const IMX_WALLET_IFRAME_STYLE = 'display: none;';
+function getIFrame() {
+    return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
 }
-// Definitions | Events
-var $207ed853f11d19d5$exports = {};
-
-$parcel$export($207ed853f11d19d5$exports, "IMTBLWidgetEvents", () => exports.IMTBLWidgetEvents);
-/**
- * Enum representing the events emitted by the widgets.
- */ exports.IMTBLWidgetEvents = void 0;
-(function(IMTBLWidgetEvents) {
-    IMTBLWidgetEvents["IMTBL_CONNECT_WIDGET_EVENT"] = "imtbl-connect-widget";
-    IMTBLWidgetEvents["IMTBL_WALLET_WIDGET_EVENT"] = "imtbl-wallet-widget";
-    IMTBLWidgetEvents["IMTBL_SWAP_WIDGET_EVENT"] = "imtbl-swap-widget";
-    IMTBLWidgetEvents["IMTBL_BRIDGE_WIDGET_EVENT"] = "imtbl-bridge-widget";
-    IMTBLWidgetEvents["IMTBL_BUY_WIDGET_EVENT"] = "imtbl-buy-widget";
-    IMTBLWidgetEvents["IMTBL_ONRAMP_WIDGET_EVENT"] = "imtbl-onramp-widget";
-})(exports.IMTBLWidgetEvents || (exports.IMTBLWidgetEvents = {}));
-
-
-var $a85ecdbd885c58ad$exports = {};
-
-$parcel$export($a85ecdbd885c58ad$exports, "ConnectEventType", () => exports.ConnectEventType);
-exports.ConnectEventType = void 0;
-(function(ConnectEventType) {
-    ConnectEventType["SUCCESS"] = "success";
-    ConnectEventType["FAILURE"] = "failure";
-    ConnectEventType["CLOSE_WIDGET"] = "close-widget";
-})(exports.ConnectEventType || (exports.ConnectEventType = {}));
-
-
-var $77b6aac5c353d4a9$exports = {};
-
-$parcel$export($77b6aac5c353d4a9$exports, "WalletEventType", () => exports.WalletEventType);
-exports.WalletEventType = void 0;
-(function(WalletEventType) {
-    WalletEventType["CLOSE_WIDGET"] = "close-widget";
-    WalletEventType["NETWORK_SWITCH"] = "network-switch";
-    WalletEventType["ADD_COINS"] = "add-coins";
-    WalletEventType["REQUEST_SWAP"] = "request-swap";
-    WalletEventType["REQUEST_BRIDGE"] = "request-bridge";
-    WalletEventType["REQUEST_ONRAMP"] = "request-onramp";
-    WalletEventType["DISCONNECT_WALLET"] = "disconnect-wallet";
-})(exports.WalletEventType || (exports.WalletEventType = {}));
-
-
-var $53d219e7f6bf0cd6$exports = {};
-
-$parcel$export($53d219e7f6bf0cd6$exports, "SwapEventType", () => exports.SwapEventType);
-/**
- * Represents an event object emitted by the Swap Widget.
- * @property {SwapEventType} type - The type of the event.
- * @property {T} data - The data contained in the event.
- */ exports.SwapEventType = void 0;
-(function(SwapEventType) {
-    SwapEventType["SUCCESS"] = "success";
-    SwapEventType["FAILURE"] = "failure";
-    SwapEventType["CLOSE_WIDGET"] = "close-widget";
-})(exports.SwapEventType || (exports.SwapEventType = {}));
-
-
-var $15cc9e120aa6f3bf$exports = {};
-
-$parcel$export($15cc9e120aa6f3bf$exports, "BridgeEventType", () => exports.BridgeEventType);
-/**
- * Represents an event object emitted by the Bridge Widget.
- * @property {BridgeEventType} type - The type of the event.
- * @property {T} data - The data associated with the event.
- */ exports.BridgeEventType = void 0;
-(function(BridgeEventType) {
-    BridgeEventType["CLOSE_WIDGET"] = "close-widget";
-    BridgeEventType["SUCCESS"] = "success";
-    BridgeEventType["FAILURE"] = "failure";
-})(exports.BridgeEventType || (exports.BridgeEventType = {}));
-
-
-var $98cbcca465beec95$exports = {};
-
-$parcel$export($98cbcca465beec95$exports, "BuyEventType", () => exports.BuyEventType);
-/**
- * Represents an event object emitted by the Buy Widget.
- * @property {BuyEventType} type - The type of the event.
- * @property {T} data - The data contained in the event.
- */ exports.BuyEventType = void 0;
-(function(BuyEventType) {
-    BuyEventType["SUCCESS"] = "success";
-    BuyEventType["FAILURE"] = "failure";
-    BuyEventType["NOT_CONNECTED"] = "not_connected";
-    BuyEventType["CLOSE"] = "close";
-})(exports.BuyEventType || (exports.BuyEventType = {}));
-
-
-var $66ceef112c0ee49e$exports = {};
-
-$parcel$export($66ceef112c0ee49e$exports, "OnRampEventType", () => exports.OnRampEventType);
-exports.OnRampEventType = void 0;
-exports.OnRampEventType || (exports.OnRampEventType = {});
-/* eslint-disable @typescript-eslint/naming-convention */ 
-
-var $14d7a2bbb79e0dae$exports = {};
-
-$parcel$export($14d7a2bbb79e0dae$exports, "Network", () => exports.Network);
-$parcel$export($14d7a2bbb79e0dae$exports, "WidgetTheme", () => exports.WidgetTheme);
-$parcel$export($14d7a2bbb79e0dae$exports, "CheckoutWidgetTagNames", () => exports.CheckoutWidgetTagNames);
-/**
- * Enum representing the networks supported by Checkout.
- */ exports.Network = void 0;
-(function(Network) {
-    Network["ETHEREUM"] = "Ethereum";
-    Network["SEPOLIA"] = "Sepolia";
-    Network["IMTBL_ZKEVM_TESTNET"] = "Immutable zkEVM Testnet";
-    Network["IMTBL_ZKEVM_DEVNET"] = "Immutable zkEVM Devnet";
-    Network["POLYGON_ZKEVM_TESTNET"] = "Polygon zkEVM Testnet";
-    Network["POLYGON_ZKEVM"] = "Polygon zkEVM";
-})(exports.Network || (exports.Network = {}));
-exports.WidgetTheme = void 0;
-(function(WidgetTheme) {
-    WidgetTheme["LIGHT"] = "light";
-    WidgetTheme["DARK"] = "dark";
-    WidgetTheme["CUSTOM"] = "custom";
-})(exports.WidgetTheme || (exports.WidgetTheme = {}));
-exports.CheckoutWidgetTagNames = void 0;
-(function(CheckoutWidgetTagNames) {
-    CheckoutWidgetTagNames["CONNECT"] = "imtbl-connect";
-    CheckoutWidgetTagNames["WALLET"] = "imtbl-wallet";
-    CheckoutWidgetTagNames["SWAP"] = "imtbl-swap";
-    CheckoutWidgetTagNames["BUY"] = "imtbl-buy";
-    CheckoutWidgetTagNames["BRIDGE"] = "imtbl-bridge";
-    CheckoutWidgetTagNames["EXAMPLE"] = "imtbl-example";
-})(exports.CheckoutWidgetTagNames || (exports.CheckoutWidgetTagNames = {}));
-
-
-var $1f969328e5988c99$exports = {};
-
-$parcel$export($1f969328e5988c99$exports, "BridgeReact", () => $1f969328e5988c99$export$30f61ebf204c69f6);
-
-
-function $1f969328e5988c99$export$30f61ebf204c69f6(props) {
-    const { providerPreference: providerPreference , fromContractAddress: fromContractAddress , amount: amount , fromNetwork: fromNetwork  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-bridge", {
-        widgetConfig: config,
-        providerPreference: providerPreference,
-        fromContractAddress: fromContractAddress ?? "",
-        fromNetwork: fromNetwork ?? "",
-        amount: amount ?? ""
+async function setupIFrame(env) {
+    return new Promise((resolve) => {
+        const iframe = document.createElement('iframe');
+        iframe.setAttribute('id', IMX_WALLET_IFRAME_ID);
+        iframe.setAttribute('src', IMX_WALLET_IFRAME_HOSTS[env]);
+        iframe.setAttribute('style', IMX_WALLET_IFRAME_STYLE);
+        document.body.appendChild(iframe);
+        iframe.onload = () => resolve(iframe);
     });
 }
-
-
-var $f22931ca9e2f35b6$exports = {};
-
-$parcel$export($f22931ca9e2f35b6$exports, "BuyReact", () => $f22931ca9e2f35b6$export$d13582032b79b401);
-
-
-function $f22931ca9e2f35b6$export$d13582032b79b401(props) {
-    const { providerPreference: providerPreference , orderId: orderId  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-buy", {
-        widgetConfig: config,
-        providerPreference: providerPreference,
-        orderId: orderId
-    });
+async function getOrSetupIFrame(env) {
+    const iframe = getIFrame();
+    if (iframe)
+        return iframe;
+    return await setupIFrame(env);
 }
 
-
-var $f2083cd30e2f5c56$exports = {};
-
-$parcel$export($f2083cd30e2f5c56$exports, "ConnectReact", () => $f2083cd30e2f5c56$export$49d62957f420a1e2);
-
-
-function $f2083cd30e2f5c56$export$49d62957f420a1e2(props) {
-    const { providerPreference: providerPreference  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-connect", {
-        widgetConfig: config,
-        providerPreference: providerPreference ?? "metamask"
+const DEFAULT_CONNECTION_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
+const CONNECTION_FAILED_ERROR = 'The L2 IMX Wallet connection has failed';
+async function connect(l1Provider, env) {
+    const l1Signer = l1Provider.getSigner();
+    const address = await l1Signer.getAddress();
+    const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
+    const iframe = await getOrSetupIFrame(env);
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.CONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success) {
+                    reject(new Error(CONNECTION_FAILED_ERROR));
+                }
+                resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.CONNECT_WALLET_REQUEST,
+            details: { ethAddress: address, signature },
+        });
     });
 }
-
-
-var $a4fbb8e3a6aeff58$exports = {};
-
-$parcel$export($a4fbb8e3a6aeff58$exports, "SwapReact", () => $a4fbb8e3a6aeff58$export$971e031379577f4);
-/* eslint-disable max-len */ 
-
-function $a4fbb8e3a6aeff58$export$971e031379577f4(props) {
-    const { providerPreference: providerPreference , fromContractAddress: fromContractAddress , amount: amount , toContractAddress: toContractAddress  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-swap", {
-        widgetConfig: config,
-        providerPreference: providerPreference,
-        fromContractAddress: fromContractAddress ?? "",
-        toContractAddress: toContractAddress ?? "",
-        amount: amount ?? ""
+async function disconnect(imxSigner) {
+    const iframe = imxSigner.getIFrame();
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.DISCONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success && messageDetails.error) {
+                    reject(messageDetails.error);
+                }
+                iframe.remove();
+                resolve();
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.DISCONNECT_WALLET_REQUEST,
+            details: { starkPublicKey: imxSigner.getAddress() },
+        });
     });
 }
 
-
-var $89d55ace0f8f1c07$exports = {};
-
-$parcel$export($89d55ace0f8f1c07$exports, "WalletReact", () => $89d55ace0f8f1c07$export$ceaac94f34dba154);
-
-
-function $89d55ace0f8f1c07$export$ceaac94f34dba154(props) {
-    const { providerPreference: providerPreference , useConnectWidget: useConnectWidget  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-wallet", {
-        widgetConfig: config,
-        useConnectWidget: useConnectWidget?.toString(),
-        providerPreference: providerPreference ?? "metamask"
-    });
+var ProviderErrorType;
+(function (ProviderErrorType) {
+    ProviderErrorType["PROVIDER_CONNECTION_ERROR"] = "PROVIDER_CONNECTION_ERROR";
+    ProviderErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
+})(ProviderErrorType || (ProviderErrorType = {}));
+class ProviderError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
 }
+const withProviderError = async (fn, customError) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
+        throw new ProviderError(errorMessage, customError.type);
+    }
+};
 
-
-var $d087956fd1002f80$exports = {};
-
-$parcel$export($d087956fd1002f80$exports, "ExampleReact", () => $d087956fd1002f80$export$fa517eee6594d26c);
-
-
-
-function $d087956fd1002f80$export$fa517eee6594d26c(props) {
-    const { providerPreference: // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    providerPreference , environment: environment , theme: theme  } = props;
-    return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-example", {
-        environment: environment ?? (exports.Environment).SANDBOX,
-        theme: theme ?? "dark",
-        providerPreference: providerPreference
-    });
+class MetaMaskIMXProvider extends GenericIMXProvider {
+    static imxSigner;
+    static async connect(config) {
+        return await withProviderError(async () => {
+            const metaMaskProvider = await connect$1({
+                chainID: config.immutableXConfig.ethConfiguration.chainID,
+            });
+            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
+            return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
+        }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
+    }
+    static async disconnect() {
+        if (!this.imxSigner) {
+            throw new ProviderError('Attempted to disconnect from the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
+        }
+        return withProviderError(async () => {
+            await disconnect(this.imxSigner);
+        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
+    }
+    static async signMessage(message) {
+        if (!this.imxSigner) {
+            throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
+        }
+        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
+    }
 }
 
-
-var $430e3eda76fa4d5f$exports = {};
-
-$parcel$export($430e3eda76fa4d5f$exports, "CheckoutWidgets", () => $430e3eda76fa4d5f$export$af210a0808087845);
-$parcel$export($430e3eda76fa4d5f$exports, "UpdateConfig", () => $430e3eda76fa4d5f$export$bf1548ba7e61c17f);
-$parcel$export($430e3eda76fa4d5f$exports, "SetProvider", () => $430e3eda76fa4d5f$export$931068bc678f0d73);
-function $430e3eda76fa4d5f$export$af210a0808087845(config) {
-    const checkoutWidgetJS = document.createElement("script");
-    checkoutWidgetJS.setAttribute("src", "http://localhost:3000/lib/js/imtbl-checkout.js");
-    document.head.appendChild(checkoutWidgetJS);
-    window.ImtblCheckoutWidgetConfig = JSON.stringify(config);
-}
-function $430e3eda76fa4d5f$export$bf1548ba7e61c17f(config) {
-    window.ImtblCheckoutWidgetConfig = JSON.stringify(config);
-}
-function $430e3eda76fa4d5f$export$931068bc678f0d73(tagName, provider) {
-    if (!provider) {
-        // eslint-disable-next-line no-console
-        console.error("no provider parsed");
-        return;
-    }
-    const elements = document.getElementsByTagName(tagName);
-    const widget = elements[0];
-    let attempts = 0;
-    const maxAttempts = 10;
-    let timer;
-    const attemptToSetProvider = ()=>{
-        try {
-            widget.setProvider(provider);
-            window.clearInterval(timer);
-        } catch (err) {
-            attempts++;
-            if (attempts >= maxAttempts) {
-                window.clearInterval(timer);
-                // eslint-disable-next-line no-console
-                console.error("failed to set the provider");
+class ProviderConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
+        }
+        else {
+            // TODO: remove once a sensible default is chosen
+            // eslint-disable-next-line default-case
+            switch (baseConfig.environment) {
+                case exports.Environment.SANDBOX: {
+                    this.immutableXConfig = coreSdk.Config.SANDBOX;
+                    break;
+                }
+                case exports.Environment.PRODUCTION: {
+                    this.immutableXConfig = coreSdk.Config.PRODUCTION;
+                    break;
+                }
             }
         }
-    };
-    timer = window.setInterval(attemptToSetProvider, 10);
-    attemptToSetProvider();
+    }
 }
 
 Object.defineProperty(exports, 'imxClientCreateStarkSigner', {
@@ -5392,23 +2560,10 @@ Object.defineProperty(exports, 'imxClientGenerateLegacyStarkPrivateKey', {
     enumerable: true,
     get: function () { return coreSdk.generateLegacyStarkPrivateKey; }
 });
-exports.guardian = guardian__namespace;
-exports.BridgeReact = $1f969328e5988c99$export$30f61ebf204c69f6;
-exports.BuyReact = $f22931ca9e2f35b6$export$d13582032b79b401;
-exports.Checkout = $a8cb37a3fc8eb863$export$1f60ba4ec72508a0;
-exports.CheckoutWidgets = $430e3eda76fa4d5f$export$af210a0808087845;
-exports.ConnectReact = $f2083cd30e2f5c56$export$49d62957f420a1e2;
-exports.ExampleReact = $d087956fd1002f80$export$fa517eee6594d26c;
 exports.GenericIMXProvider = GenericIMXProvider;
 exports.ImmutableConfiguration = ImmutableConfiguration;
 exports.ImmutableXClient = ImmutableXClient;
 exports.MetaMaskIMXProvider = MetaMaskIMXProvider;
-exports.Orderbook = Orderbook;
 exports.Passport = Passport;
 exports.PassportError = PassportError;
 exports.ProviderConfiguration = ProviderConfiguration;
-exports.SetProvider = $430e3eda76fa4d5f$export$931068bc678f0d73;
-exports.SwapReact = $a4fbb8e3a6aeff58$export$971e031379577f4;
-exports.UpdateConfig = $430e3eda76fa4d5f$export$bf1548ba7e61c17f;
-exports.WalletReact = $89d55ace0f8f1c07$export$ceaac94f34dba154;
-exports.module = module$1;