@imtbl/sdk 0.1.6 → 0.1.7-alpha.1

package/dist/index.js

@@ -1,11 +1,23 @@
-import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
+import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi } from '@imtbl/core-sdk';
 export { createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey } from '@imtbl/core-sdk';
+import * as guardian from '@imtbl/guardian';
+export { guardian };
 import { UserManager } from 'oidc-client-ts';
-import { ethers } from 'ethers';
+import { ethers, utils, Contract, BigNumber, constants } from 'ethers';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
+import { ItemType, SEAPORT_CONTRACT_NAME, SEAPORT_CONTRACT_VERSION_V1_4, EIP_712_ORDER_TYPE, OrderType } from '@opensea/seaport-js/lib/constants';
+import FormData from 'form-data';
+import fetch, { Headers } from 'node-fetch';
+import { Seaport as Seaport$1 } from '@opensea/seaport-js';
+import { parseUnits } from '@ethersproject/units';
+import { BigNumber as BigNumber$1 } from '@ethersproject/bignumber';
+import detectEthereumProvider from '@metamask/detect-provider';
+import { Web3Provider } from '@ethersproject/providers';
+import { jsx } from 'react/jsx-runtime';
+import 'react';
 
 var Environment;
 (function (Environment) {
@@ -29,7 +41,7 @@ const production = () => Config.createConfig({
     chainID: 1,
     coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
     registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
-    sdkVersion: 'ts-immutable-sdk-0.0.0',
+    sdkVersion: 'ts-immutable-sdk-0.1.7-alpha.1',
 });
 /**
  * Set `sdkVersion` on config
@@ -39,7 +51,7 @@ const sandbox = () => Config.createConfig({
     chainID: 5,
     coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
     registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
-    sdkVersion: 'ts-immutable-sdk-0.0.0',
+    sdkVersion: 'ts-immutable-sdk-0.1.7-alpha.1',
 });
 class ImxConfiguration {
     immutableXConfig;
@@ -528,30 +540,40 @@ class ImmutableXClient {
 function serializeEthSignature(sig) {
     // This is because golang appends a recovery param
     // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64) +
-        encUtils.padLeft(sig.s.toString(16), 64) +
-        encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
+        + encUtils.padLeft(sig.s.toString(16), 64)
+        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
 }
 function importRecoveryParam(v) {
+    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
+        ? new BN(v, 16).sub(new BN(27)).toNumber()
+        : new BN(v, 16).toNumber();
     return v.trim()
-        ? new BN(v, 16).cmp(new BN(27)) !== -1
-            ? new BN(v, 16).sub(new BN(27)).toNumber()
-            : new BN(v, 16).toNumber()
+        ? isValidBigNumber
         : undefined;
 }
 // used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
 function deserializeSignature(sig, size = 64) {
-    sig = encUtils.removeHexPrefix(sig);
+    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
     return {
-        r: new BN(sig.substring(0, size), 'hex'),
-        s: new BN(sig.substring(size, size * 2), 'hex'),
-        recoveryParam: importRecoveryParam(sig.substring(size * 2, size * 2 + 2)),
+        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
+        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
     };
 }
 async function signRaw(payload, signer) {
     const signature = deserializeSignature(await signer.signMessage(payload));
     return serializeEthSignature(signature);
 }
+async function signMessage(message, signer) {
+    const ethAddress = await signer.getAddress();
+    const ethSignature = await signRaw(message, signer);
+    return {
+        message,
+        ethAddress,
+        ethSignature,
+    };
+}
 
 /**
  * Helper method to convert token type to a SignableToken type
@@ -576,6 +598,7 @@ function convertToSignableToken(token) {
                 },
             };
         case 'ETH':
+        default:
             return {
                 type: 'ETH',
                 data: {
@@ -879,7 +902,7 @@ class ConfirmationScreen {
 }
 
 const ERC721$1 = 'ERC721';
-const transfer = ({ request, transfersApi, starkSigner, user, passportConfig,
+const transfer$1 = ({ request, transfersApi, starkSigner, user, passportConfig,
 // TODO: remove this eslint disable once we have a better solution
 // eslint-disable-next-line max-len
  }) => withPassportError(async () => {
@@ -989,12 +1012,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
     }, PassportErrorType.TRANSFER_ERROR);
 }
 
-const ERC721 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, passportConfig, }) {
+const ERC721$2 = 'ERC721';
+async function createOrder$1({ starkSigner, user, request, ordersApi, passportConfig, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
-        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
-        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
+        const amountSell = request.sell.type === ERC721$2 ? '1' : request.sell.amount;
+        const amountBuy = request.buy.type === ERC721$2 ? '1' : request.buy.amount;
         const getSignableOrderRequestV3 = {
             user: ethAddress,
             amount_buy: amountBuy,
@@ -1046,7 +1069,7 @@ async function createOrder({ starkSigner, user, request, ordersApi, passportConf
         };
     }, PassportErrorType.CREATE_ORDER_ERROR);
 }
-async function cancelOrder({ user, starkSigner, request, ordersApi, passportConfig, }) {
+async function cancelOrder$1({ user, starkSigner, request, ordersApi, passportConfig, }) {
     return withPassportError(async () => {
         const getSignableCancelOrderRequest = {
             order_id: request.order_id,
@@ -1082,7 +1105,7 @@ async function cancelOrder({ user, starkSigner, request, ordersApi, passportConf
     }, PassportErrorType.CANCEL_ORDER_ERROR);
 }
 
-async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
+async function exchangeTransfer$1({ user, starkSigner, request, exchangesApi, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
         const transferAmount = request.amount;
@@ -1126,7 +1149,7 @@ async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
     }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
 }
 
-async function createTrade({ request, tradesApi, user, starkSigner, passportConfig, }) {
+async function createTrade$1({ request, tradesApi, user, starkSigner, passportConfig, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
         const getSignableTradeRequest = {
@@ -1188,7 +1211,7 @@ class PassportImxProvider {
         this.immutableXClient = immutableXClient;
     }
     async transfer(request) {
-        return transfer({
+        return transfer$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
@@ -1207,7 +1230,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     createOrder(request) {
-        return createOrder({
+        return createOrder$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
@@ -1216,7 +1239,7 @@ class PassportImxProvider {
         });
     }
     cancelOrder(request) {
-        return cancelOrder({
+        return cancelOrder$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
@@ -1225,7 +1248,7 @@ class PassportImxProvider {
         });
     }
     createTrade(request) {
-        return createTrade({
+        return createTrade$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
@@ -1243,7 +1266,7 @@ class PassportImxProvider {
         });
     }
     exchangeTransfer(request) {
-        return exchangeTransfer({
+        return exchangeTransfer$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
@@ -1270,7 +1293,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     getAddress() {
-        return Promise.resolve(this.starkSigner.getAddress());
+        return Promise.resolve(this.user.etherKey);
     }
 }
 
@@ -1380,6 +1403,7 @@ async function registerPassport({ ethSigner, starkSigner, usersApi }, authorizat
 }
 
 // TODO: Remove this once the dependency has been added
+// eslint-disable-next-line import/no-extraneous-dependencies
 class Passport {
     authManager;
     magicAdapter;
@@ -1461,4 +1485,3883 @@ class Passport {
     }
 }
 
-export { Environment, ImmutableConfiguration, ImmutableXClient, Passport, PassportError };
+class BaseHttpRequest {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}
+
+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;
+    }
+}
+
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+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'));
+    }
+    get isCancelled() {
+        return this._isCancelled;
+    }
+}
+
+/* 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))}`);
+    };
+    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);
+            }
+        }
+    };
+    Object.entries(params).forEach(([key, value]) => {
+        process(key, value);
+    });
+    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 url = `${config.BASE}${path}`;
+    if (options.query) {
+        return `${url}${getQueryString(options.query)}`;
+    }
+    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;
+    }
+    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 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,
+    };
+    const error = errors[result.status];
+    if (error) {
+        throw new ApiError(options, result, error);
+    }
+    if (!result.ok) {
+        throw new ApiError(options, result, 'Generic Error');
+    }
+};
+/**
+ * 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);
+        }
+    });
+};
+
+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);
+    }
+}
+
+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`,
+            },
+        });
+    }
+}
+
+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);
+    }
+}
+
+/* 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) !== 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) === 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(),
+            },
+        });
+    }
+}
+
+class ImmutableApiClientFactory {
+    chainId;
+    orderbookClient;
+    constructor(apiEndpoint, chainId) {
+        this.chainId = chainId;
+        this.orderbookClient = new OrderBookClient({
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            BASE: apiEndpoint,
+        });
+    }
+    create() {
+        return new ImmutableApiClient(this.orderbookClient.orders, this.chainId);
+    }
+}
+
+class ERC721 {
+    erc721;
+    constructor(erc721) {
+        this.erc721 = erc721;
+    }
+    async royaltyInfo(tokenId, salePrice) {
+        const [recipient, royaltyRequired] = await this.erc721.royaltyInfo(tokenId, salePrice);
+        return { recipient, amountRequired: royaltyRequired.toString() };
+    }
+}
+
+/* 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 utils.Interface(_abi);
+    }
+    static connect(address, signerOrProvider) {
+        return new 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 = 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' ? ItemType.ERC20 : ItemType.NATIVE,
+        recipient: order.account_address,
+        token: buyItem.contract_address || constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    const fees = order.buy_fees.map((fee) => ({
+        startAmount: fee.amount,
+        endAmount: fee.amount,
+        itemType: order.buy[0].item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
+        recipient: fee.recipient,
+        token: order.buy[0].contract_address || constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    return {
+        conduitKey: constants.HashZero,
+        consideration: [...considerationItems, ...fees],
+        offer: order.sell.map((sellItem) => ({
+            startAmount: '1',
+            endAmount: '1',
+            itemType: 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: OrderType.FULL_RESTRICTED,
+        zoneHash: 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: 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: SEAPORT_CONTRACT_NAME,
+            version: SEAPORT_CONTRACT_VERSION_V1_4,
+            chainId,
+            verifyingContract: this.seaportContractAddress,
+        };
+        return {
+            domain: domainData,
+            types: EIP_712_ORDER_TYPE,
+            value: orderComponents,
+        };
+    }
+}
+
+class SeaportFactory {
+    seaportContractAddress;
+    zoneContractAddress;
+    provider;
+    seaport;
+    constructor(seaportContractAddress, zoneContractAddress, provider) {
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+        this.provider = provider;
+        this.seaport = new Seaport$1(provider, {
+            seaportVersion: '1.4',
+            balanceAndApprovalChecksOnOrderCreation: true,
+            overrides: {
+                contractAddress: seaportContractAddress,
+            },
+        });
+    }
+    create() {
+        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
+    }
+}
+
+/**
+ * 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 };
+    }
+}
+
+const module = 'orderbook';
+
+function isChainValid(chainID, config) {
+    return chainID === config.ethConfiguration.chainID;
+}
+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.');
+    }
+}
+
+async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new 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,
+    };
+}
+async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new 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');
+    }
+    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,
+    };
+}
+
+async function createOrder({ signers, request, config, }) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const ordersApi = new 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 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 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,
+    };
+}
+
+async function registerOffchain(signers, config) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const usersApi = new 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 isRegisteredOnChain(starkPublicKey, ethSigner, config) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const registrationContract = 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 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 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,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return prepareWithdrawalResponse.data;
+}
+
+async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
+    const encodingApi = new EncodingApi(config.apiConfiguration);
+    const result = await encodingApi.encodeAsset({
+        assetType,
+        encodeAssetRequest: {
+            token: {
+                type: tokenType,
+                ...(tokenData && { data: tokenData }),
+            },
+        },
+    });
+    return result.data;
+}
+
+async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
+    const etherKey = await ethSigner.getAddress();
+    const imxConfig = config.immutableXConfig;
+    const usersApi = new UsersApi(imxConfig.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = 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 = 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 = 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 UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = 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.sanitizeHex(encUtils.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 UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = 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 = 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 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 UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = 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 = 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);
+    }
+    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+}
+
+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: 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 createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const tradesApi = new 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 = 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 = 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 = parseUnits(deposit.amount, 'wei');
+    const imxConfig = config.immutableXConfig;
+    const depositsApi = new DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new 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 = 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 = 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 TokensApi(apiConfiguration);
+    const depositsApi = new DepositsApi(apiConfiguration);
+    const encodingApi = new EncodingApi(apiConfiguration);
+    const usersApi = new 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 = 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 = 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$1.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 = 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 DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new 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 = 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 = 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 });
+        case 'ERC20':
+            return depositERC20({ signers, deposit, config });
+        case 'ERC721':
+            return depositERC721({ signers, deposit, config });
+    }
+}
+
+async function exchangeTransfer({ signers, request, config, }) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const exchangeApi = new ExchangesApi(config.immutableXConfig.apiConfiguration);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const transferAmount = request.amount;
+    const signableResult = await exchangeApi.getExchangeSignableTransfer({
+        id: request.transactionID,
+        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, signers.ethSigner);
+    const starkSignature = await signers.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 exchangeApi.createExchangeTransfer({
+        id: request.transactionID,
+        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 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.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 = {
+    [Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
+    [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 Environment.SANDBOX: {
+                    this.immutableXConfig = Config.SANDBOX;
+                    break;
+                }
+                case Environment.PRODUCTION: {
+                    this.immutableXConfig = Config.PRODUCTION;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+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"
+    }
+];
+
+
+
+const $bc2bfebf768286d3$export$6a2ba3c3bd042990 = {
+    baseConfig: {
+        environment: (Environment).SANDBOX
+    }
+};
+
+
+let $d176a05e966364ba$export$3bfad4d03ada24c4;
+(function(ConnectionProviders) {
+    ConnectionProviders["METAMASK"] = "metamask";
+})($d176a05e966364ba$export$3bfad4d03ada24c4 || ($d176a05e966364ba$export$3bfad4d03ada24c4 = {}));
+
+
+let $a47e48dd2c04791b$export$c06e1e7429de6283;
+(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";
+})($a47e48dd2c04791b$export$c06e1e7429de6283 || ($a47e48dd2c04791b$export$c06e1e7429de6283 = {}));
+const $a47e48dd2c04791b$export$6f24f3cef7d501c4 = new Map([
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.ETHEREUM,
+        {
+            chainIdHex: "0x1",
+            chainName: "Ethereum",
+            rpcUrls: [
+                "https://mainnet.infura.io/v3/"
+            ],
+            nativeCurrency: {
+                name: "Ethereum",
+                symbol: "ETH",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://etherscan.io/"
+            ]
+        }
+    ],
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.IMTBL_ZKEVM_TESTNET,
+        {
+            chainIdHex: "0x343C",
+            chainName: "Immutable zkEVM Testnet",
+            rpcUrls: [
+                "https://zkevm-rpc.sandbox.x.immutable.com"
+            ],
+            nativeCurrency: {
+                name: "IMX",
+                symbol: "IMX",
+                decimals: 18
+            }
+        }
+    ],
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.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([
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.SEPOLIA,
+        {
+            chainIdHex: "0xaa36a7",
+            chainName: "Sepolia",
+            rpcUrls: [
+                "https://sepolia.infura.io/v3/"
+            ],
+            nativeCurrency: {
+                name: "Sep Eth",
+                symbol: "ETH",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://sepolia.etherscan.io/"
+            ]
+        }
+    ],
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.IMTBL_ZKEVM_DEVNET,
+        {
+            chainIdHex: "0x343D",
+            chainName: "Immutable zkEVM Devnet",
+            rpcUrls: [
+                "https://zkevm-rpc.dev.x.immutable.com/"
+            ],
+            nativeCurrency: {
+                name: "IMX",
+                symbol: "IMX",
+                decimals: 18
+            }
+        }
+    ],
+    [
+        $a47e48dd2c04791b$export$c06e1e7429de6283.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"
+            ]
+        }
+    ]
+]);
+let $a47e48dd2c04791b$export$1f05a55fe0680cc7;
+(function(NetworkFilterTypes) {
+    NetworkFilterTypes["ALL"] = "all";
+})($a47e48dd2c04791b$export$1f05a55fe0680cc7 || ($a47e48dd2c04791b$export$1f05a55fe0680cc7 = {}));
+
+
+// TODO: fix circular dependency
+// eslint-disable-next-line import/no-cycle
+let $08d5ddc39acd6833$export$fd9b17d87f4121d2;
+(function(TokenFilterTypes) {
+    TokenFilterTypes["SWAP"] = "swap";
+    TokenFilterTypes["BRIDGE"] = "bridge";
+    TokenFilterTypes["ALL"] = "all";
+})($08d5ddc39acd6833$export$fd9b17d87f4121d2 || ($08d5ddc39acd6833$export$fd9b17d87f4121d2 = {}));
+
+
+
+
+// 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 = {}));
+let $4f91c5f280efe242$export$a75605c67ea83a5a;
+(function(WalletFilterTypes) {
+    WalletFilterTypes["ALL"] = "all";
+    WalletFilterTypes["DESKTOP"] = "desktop";
+    WalletFilterTypes["MOBILE"] = "mobile";
+})($4f91c5f280efe242$export$a75605c67ea83a5a || ($4f91c5f280efe242$export$a75605c67ea83a5a = {}));
+
+
+
+
+/**
+ * The different types of errors that can be returned by the checkout process.
+ */ let $a8bc256d81a5e2c1$export$e3dc0620abde7f5a;
+(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";
+})($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
+class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
+    constructor(message, type, data){
+        super(message);
+        this.message = message;
+        this.type = type;
+        this.data = data;
+    }
+}
+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
+        });
+    }
+};
+
+
+
+
+/* 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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR
+    });
+    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
+    return new (Web3Provider)(provider);
+}
+async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
+    let web3Provider = null;
+    switch(providerPreference){
+        case ($d176a05e966364ba$export$3bfad4d03ada24c4).METAMASK:
+            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
+            break;
+        default:
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_PREFERENCE_ERROR);
+    }
+    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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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: []
+        });
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Check wallet connection request failed", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_FAILED_ERROR, {
+            rpcMethod: ($4f91c5f280efe242$export$35b06f0d33f57e26).CHECK_CONNECTION
+        });
+    }
+    // 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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
+            details: `Unsupported provider for ${params.providerPreference}`
+        });
+        // 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: []
+        });
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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
+            ]
+        });
+    }
+}
+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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_NETWORK_INFO_ERROR
+    });
+}
+async function $de192de6ef100f9f$export$b827d9418aeb5dbd(config, providerPreference, provider, chainId) {
+    let currentProvider = provider;
+    const { networkMap: networkMap  } = config;
+    if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!currentProvider || !currentProvider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
+        }
+        else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
+    }
+    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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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 = ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL , exclude: exclude  }) {
+    const { networkMap: networkMap  } = config;
+    const list = ((/*@__PURE__*/$parcel$interopDefault($497c134ecbc8a50f$exports))).filter((network)=>{
+        const allowAllTokens = type === ($a47e48dd2c04791b$export$1f05a55fe0680cc7).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
+        });
+    });
+    return {
+        networks: allowedNetworks
+    };
+}
+
+
+
+
+
+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 === ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL;
+        const tokenAllowedForType = token.tokenFeatures.includes(type);
+        return (skipChainIdCheck || chainIdMatches) && tokenNotExcluded && (allowAllTokens || tokenAllowedForType);
+    });
+const $efe60cea83bfc4e8$export$473cec51305fdae8 = async ({ type: type = ($08d5ddc39acd6833$export$fd9b17d87f4121d2).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 $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`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR, {
+            chainName: networkInfo.name
+        });
+        const balance = await provider.getBalance(walletAddress);
+        return {
+            balance: balance,
+            formattedBalance: (utils).formatUnits(balance, networkInfo.nativeCurrency.decimals),
+            token: networkInfo.nativeCurrency
+        };
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_BALANCE_ERROR
+    });
+async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, contractAddress) {
+    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const contract = new (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 = (utils).formatUnits(balance, decimals);
+        return {
+            balance: balance,
+            formattedBalance: formattedBalance,
+            token: {
+                name: name,
+                symbol: symbol,
+                decimals: decimals,
+                address: contractAddress
+            }
+        };
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC20_BALANCE_ERROR
+    });
+}
+const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, provider, walletAddress, chainId)=>{
+    if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`ChainId ${chainId} is not supported`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
+    const tokenList = await ($efe60cea83bfc4e8$export$473cec51305fdae8)({
+        type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).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 = ($4f91c5f280efe242$export$a75605c67ea83a5a).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 === ($4f91c5f280efe242$export$a75605c67ea83a5a).ALL;
+        const walletsAllowedForType = wallet.platform.includes(type);
+        return walletNotExcluded && (allowAllWallets || walletsAllowedForType);
+    }).map((wallet)=>{
+        const { platform: platform , ...walletInfo } = wallet;
+        return walletInfo;
+    });
+    return {
+        wallets: filteredWalletsList
+    };
+}
+
+
+
+
+
+
+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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).TRANSACTION_ERROR
+    });
+};
+
+
+
+
+
+
+
+
+class $4013c5c91bb535f6$export$47a4ed4a38b9eecf extends Error {
+    constructor(message){
+        super(message);
+        this.message = message;
+    }
+}
+class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
+    constructor(config){
+        // validate input
+        if (!Object.values((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 === (Environment).PRODUCTION ? ($a47e48dd2c04791b$export$6f24f3cef7d501c4) : ($a47e48dd2c04791b$export$3e81fc0987227f10);
+    }
+}
+
+
+
+
+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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+// Definitions | Events
+var $207ed853f11d19d5$exports = {};
+
+$parcel$export($207ed853f11d19d5$exports, "IMTBLWidgetEvents", () => $207ed853f11d19d5$export$5a0ace85cae72d45);
+/**
+ * Enum representing the events emitted by the widgets.
+ */ let $207ed853f11d19d5$export$5a0ace85cae72d45;
+(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";
+})($207ed853f11d19d5$export$5a0ace85cae72d45 || ($207ed853f11d19d5$export$5a0ace85cae72d45 = {}));
+
+
+var $a85ecdbd885c58ad$exports = {};
+
+$parcel$export($a85ecdbd885c58ad$exports, "ConnectEventType", () => $a85ecdbd885c58ad$export$e72e7f9969a47dd3);
+let $a85ecdbd885c58ad$export$e72e7f9969a47dd3;
+(function(ConnectEventType) {
+    ConnectEventType["SUCCESS"] = "success";
+    ConnectEventType["FAILURE"] = "failure";
+    ConnectEventType["CLOSE_WIDGET"] = "close-widget";
+})($a85ecdbd885c58ad$export$e72e7f9969a47dd3 || ($a85ecdbd885c58ad$export$e72e7f9969a47dd3 = {}));
+
+
+var $77b6aac5c353d4a9$exports = {};
+
+$parcel$export($77b6aac5c353d4a9$exports, "WalletEventType", () => $77b6aac5c353d4a9$export$d9be06b70b28c742);
+let $77b6aac5c353d4a9$export$d9be06b70b28c742;
+(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";
+})($77b6aac5c353d4a9$export$d9be06b70b28c742 || ($77b6aac5c353d4a9$export$d9be06b70b28c742 = {}));
+
+
+var $53d219e7f6bf0cd6$exports = {};
+
+$parcel$export($53d219e7f6bf0cd6$exports, "SwapEventType", () => $53d219e7f6bf0cd6$export$140a49745ab55563);
+/**
+ * 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.
+ */ let $53d219e7f6bf0cd6$export$140a49745ab55563;
+(function(SwapEventType) {
+    SwapEventType["SUCCESS"] = "success";
+    SwapEventType["FAILURE"] = "failure";
+    SwapEventType["CLOSE_WIDGET"] = "close-widget";
+})($53d219e7f6bf0cd6$export$140a49745ab55563 || ($53d219e7f6bf0cd6$export$140a49745ab55563 = {}));
+
+
+var $15cc9e120aa6f3bf$exports = {};
+
+$parcel$export($15cc9e120aa6f3bf$exports, "BridgeEventType", () => $15cc9e120aa6f3bf$export$d1bfa21f7c76447a);
+/**
+ * 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.
+ */ let $15cc9e120aa6f3bf$export$d1bfa21f7c76447a;
+(function(BridgeEventType) {
+    BridgeEventType["CLOSE_WIDGET"] = "close-widget";
+    BridgeEventType["SUCCESS"] = "success";
+    BridgeEventType["FAILURE"] = "failure";
+})($15cc9e120aa6f3bf$export$d1bfa21f7c76447a || ($15cc9e120aa6f3bf$export$d1bfa21f7c76447a = {}));
+
+
+var $98cbcca465beec95$exports = {};
+
+$parcel$export($98cbcca465beec95$exports, "BuyEventType", () => $98cbcca465beec95$export$90db5fe1be5993c1);
+/**
+ * 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.
+ */ let $98cbcca465beec95$export$90db5fe1be5993c1;
+(function(BuyEventType) {
+    BuyEventType["SUCCESS"] = "success";
+    BuyEventType["FAILURE"] = "failure";
+    BuyEventType["NOT_CONNECTED"] = "not_connected";
+    BuyEventType["CLOSE"] = "close";
+})($98cbcca465beec95$export$90db5fe1be5993c1 || ($98cbcca465beec95$export$90db5fe1be5993c1 = {}));
+
+
+var $66ceef112c0ee49e$exports = {};
+
+$parcel$export($66ceef112c0ee49e$exports, "OnRampEventType", () => $66ceef112c0ee49e$export$66ec39c0924078d8);
+let $66ceef112c0ee49e$export$66ec39c0924078d8;
+$66ceef112c0ee49e$export$66ec39c0924078d8 || ($66ceef112c0ee49e$export$66ec39c0924078d8 = {});
+/* eslint-disable @typescript-eslint/naming-convention */ 
+
+var $14d7a2bbb79e0dae$exports = {};
+
+$parcel$export($14d7a2bbb79e0dae$exports, "Network", () => $14d7a2bbb79e0dae$export$95be4ae94445245a);
+$parcel$export($14d7a2bbb79e0dae$exports, "WidgetTheme", () => $14d7a2bbb79e0dae$export$c88931fdc51854eb);
+$parcel$export($14d7a2bbb79e0dae$exports, "CheckoutWidgetTagNames", () => $14d7a2bbb79e0dae$export$75be0f6af9650f2c);
+/**
+ * Enum representing the networks supported by Checkout.
+ */ let $14d7a2bbb79e0dae$export$95be4ae94445245a;
+(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";
+})($14d7a2bbb79e0dae$export$95be4ae94445245a || ($14d7a2bbb79e0dae$export$95be4ae94445245a = {}));
+let $14d7a2bbb79e0dae$export$c88931fdc51854eb;
+(function(WidgetTheme) {
+    WidgetTheme["LIGHT"] = "light";
+    WidgetTheme["DARK"] = "dark";
+    WidgetTheme["CUSTOM"] = "custom";
+})($14d7a2bbb79e0dae$export$c88931fdc51854eb || ($14d7a2bbb79e0dae$export$c88931fdc51854eb = {}));
+let $14d7a2bbb79e0dae$export$75be0f6af9650f2c;
+(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";
+})($14d7a2bbb79e0dae$export$75be0f6af9650f2c || ($14d7a2bbb79e0dae$export$75be0f6af9650f2c = {}));
+
+
+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__*/ (jsx)("imtbl-bridge", {
+        widgetConfig: config,
+        providerPreference: providerPreference,
+        fromContractAddress: fromContractAddress ?? "",
+        fromNetwork: fromNetwork ?? "",
+        amount: amount ?? ""
+    });
+}
+
+
+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__*/ (jsx)("imtbl-buy", {
+        widgetConfig: config,
+        providerPreference: providerPreference,
+        orderId: orderId
+    });
+}
+
+
+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__*/ (jsx)("imtbl-connect", {
+        widgetConfig: config,
+        providerPreference: providerPreference ?? "metamask"
+    });
+}
+
+
+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__*/ (jsx)("imtbl-swap", {
+        widgetConfig: config,
+        providerPreference: providerPreference,
+        fromContractAddress: fromContractAddress ?? "",
+        toContractAddress: toContractAddress ?? "",
+        amount: amount ?? ""
+    });
+}
+
+
+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__*/ (jsx)("imtbl-wallet", {
+        widgetConfig: config,
+        useConnectWidget: useConnectWidget?.toString(),
+        providerPreference: providerPreference ?? "metamask"
+    });
+}
+
+
+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__*/ (jsx)("imtbl-example", {
+        environment: environment ?? (Environment).SANDBOX,
+        theme: theme ?? "dark",
+        providerPreference: providerPreference
+    });
+}
+
+
+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");
+            }
+        }
+    };
+    timer = window.setInterval(attemptToSetProvider, 10);
+    attemptToSetProvider();
+}
+
+export { $15cc9e120aa6f3bf$export$d1bfa21f7c76447a as BridgeEventType, $1f969328e5988c99$export$30f61ebf204c69f6 as BridgeReact, $98cbcca465beec95$export$90db5fe1be5993c1 as BuyEventType, $f22931ca9e2f35b6$export$d13582032b79b401 as BuyReact, $a47e48dd2c04791b$export$c06e1e7429de6283 as ChainId, $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 as Checkout, $a8bc256d81a5e2c1$export$e3dc0620abde7f5a as CheckoutErrorType, $14d7a2bbb79e0dae$export$75be0f6af9650f2c as CheckoutWidgetTagNames, $430e3eda76fa4d5f$export$af210a0808087845 as CheckoutWidgets, $a85ecdbd885c58ad$export$e72e7f9969a47dd3 as ConnectEventType, $f2083cd30e2f5c56$export$49d62957f420a1e2 as ConnectReact, $d176a05e966364ba$export$3bfad4d03ada24c4 as ConnectionProviders, Environment, $d087956fd1002f80$export$fa517eee6594d26c as ExampleReact, GenericIMXProvider, $207ed853f11d19d5$export$5a0ace85cae72d45 as IMTBLWidgetEvents, ImmutableConfiguration, ImmutableXClient, MetaMaskIMXProvider, $14d7a2bbb79e0dae$export$95be4ae94445245a as Network, $a47e48dd2c04791b$export$1f05a55fe0680cc7 as NetworkFilterTypes, $66ceef112c0ee49e$export$66ec39c0924078d8 as OnRampEventType, Orderbook, Passport, PassportError, ProviderConfiguration, $430e3eda76fa4d5f$export$931068bc678f0d73 as SetProvider, $53d219e7f6bf0cd6$export$140a49745ab55563 as SwapEventType, $a4fbb8e3a6aeff58$export$971e031379577f4 as SwapReact, $08d5ddc39acd6833$export$fd9b17d87f4121d2 as TokenFilterTypes, $430e3eda76fa4d5f$export$bf1548ba7e61c17f as UpdateConfig, $77b6aac5c353d4a9$export$d9be06b70b28c742 as WalletEventType, $4f91c5f280efe242$export$a75605c67ea83a5a as WalletFilterTypes, $89d55ace0f8f1c07$export$ceaac94f34dba154 as WalletReact, $14d7a2bbb79e0dae$export$c88931fdc51854eb as WidgetTheme, module };