@imtbl/sdk 0.1.6-alpha → 0.1.7-alpha.1

package/dist/index.cjs

@@ -1,12 +1,17 @@
 'use strict';
 
 var coreSdk = require('@imtbl/core-sdk');
+var guardian = require('@imtbl/guardian');
 var oidcClientTs = require('oidc-client-ts');
 var ethers = require('ethers');
 var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
 var BN = require('bn.js');
 var encUtils = require('enc-utils');
+var constants = require('@opensea/seaport-js/lib/constants');
+var FormData = require('form-data');
+var fetch = require('node-fetch');
+var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
 var detectEthereumProvider = require('@metamask/detect-provider');
@@ -31,6 +36,7 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
+var guardian__namespace = /*#__PURE__*/_interopNamespaceDefault(guardian);
 var encUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(encUtils);
 
 exports.Environment = void 0;
@@ -554,24 +560,25 @@ class ImmutableXClient {
 function serializeEthSignature(sig) {
     // This is because golang appends a recovery param
     // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils__namespace.addHexPrefix(encUtils__namespace.padLeft(sig.r.toString(16), 64) +
-        encUtils__namespace.padLeft(sig.s.toString(16), 64) +
-        encUtils__namespace.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+    return encUtils__namespace.addHexPrefix(encUtils__namespace.padLeft(sig.r.toString(16), 64)
+        + encUtils__namespace.padLeft(sig.s.toString(16), 64)
+        + encUtils__namespace.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__namespace.removeHexPrefix(sig);
+    const removedHexPrefixSig = encUtils__namespace.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) {
@@ -611,6 +618,7 @@ function convertToSignableToken(token) {
                 },
             };
         case 'ETH':
+        default:
             return {
                 type: 'ETH',
                 data: {
@@ -1024,12 +1032,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
     }, PassportErrorType.TRANSFER_ERROR);
 }
 
-const ERC721 = 'ERC721';
+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,
@@ -1305,7 +1313,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);
     }
 }
 
@@ -1415,6 +1423,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;
@@ -1458,51 +1467,1878 @@ class Passport {
         if (!user) {
             return null;
         }
-        return this.getImxProvider(user);
-    }
-    async connectImx() {
-        const user = await this.authManager.login();
-        return this.getImxProvider(user);
-    }
-    async loginCallback() {
-        return this.authManager.loginCallback();
+        return this.getImxProvider(user);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
+    }
+    async loginCallback() {
+        return this.authManager.loginCallback();
+    }
+    async logout() {
+        return this.authManager.logout();
+    }
+    async getUserInfo() {
+        const user = await this.authManager.getUser();
+        return user?.profile;
+    }
+    async getIdToken() {
+        const user = await this.authManager.getUser();
+        return user?.idToken;
+    }
+    async getAccessToken() {
+        const user = await this.authManager.getUser();
+        return user?.accessToken;
+    }
+    async registerUser(userAdminKeySigner, starkSigner, jwt) {
+        await registerPassport({
+            ethSigner: userAdminKeySigner,
+            starkSigner,
+            usersApi: this.immutableXClient.usersApi,
+        }, jwt);
+        const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
+        if (!updatedUser) {
+            throw new PassportError('Failed to get refresh token', PassportErrorType.REFRESH_TOKEN_ERROR);
+        }
+        return updatedUser;
+    }
+}
+
+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 fetch.Headers(headers);
+};
+const getRequestBody = (options) => {
+    if (options.body) {
+        if (options.mediaType?.includes('/json')) {
+            return JSON.stringify(options.body);
+        }
+        else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+            return options.body;
+        }
+        else {
+            return JSON.stringify(options.body);
+        }
+    }
+    return undefined;
+};
+const sendRequest = async (options, url, body, formData, headers, onCancel) => {
+    const controller = new AbortController();
+    const request = {
+        headers,
+        method: options.method,
+        body: body ?? formData,
+        signal: controller.signal,
+    };
+    onCancel(() => controller.abort());
+    return await fetch(url, request);
+};
+const getResponseHeader = (response, responseHeader) => {
+    if (responseHeader) {
+        const content = response.headers.get(responseHeader);
+        if (isString(content)) {
+            return content;
+        }
+    }
+    return undefined;
+};
+const getResponseBody = async (response) => {
+    if (response.status !== 204) {
+        try {
+            const contentType = response.headers.get('Content-Type');
+            if (contentType) {
+                const isJSON = contentType.toLowerCase().startsWith('application/json');
+                if (isJSON) {
+                    return await response.json();
+                }
+                else {
+                    return await response.text();
+                }
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    return undefined;
+};
+const catchErrorCodes = (options, result) => {
+    const errors = {
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        ...options.errors,
+    };
+    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) !== constants.ItemType.ERC721) {
+            throw new Error('Only ERC721 tokens can be listed');
+        }
+        const considerationItemTypeTheSame = new Set([...orderComponents.consideration.map((c) => c.itemType)]).size === 1;
+        if (!considerationItemTypeTheSame) {
+            throw new Error('All consideration items must be of the same type');
+        }
+        return this.orderbookService.createOrder({
+            chainId: this.chainId,
+            requestBody: {
+                order_hash: orderHash,
+                account_address: offerer,
+                buy: [
+                    {
+                        item_type: Number(orderComponents.consideration[0].itemType) === constants.ItemType.NATIVE
+                            ? BuyItem.item_type.IMX
+                            : BuyItem.item_type.ERC20,
+                        start_amount: orderComponents.consideration[0].startAmount,
+                    }
+                ],
+                buy_fees: orderComponents.consideration.length > 1
+                    ? [
+                        {
+                            amount: orderComponents.consideration[1].startAmount,
+                            recipient: orderComponents.consideration[1].recipient,
+                            fee_type: Fee.fee_type.ROYALTY,
+                        },
+                    ]
+                    : [],
+                end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
+                protocol_data: {
+                    order_type: CreateOrderProtocolData.order_type.FULL_OPEN,
+                    zone_address: orderComponents.zone,
+                },
+                salt: orderComponents.salt,
+                sell: [{
+                        contract_address: orderComponents.offer[0].token,
+                        token_id: orderComponents.offer[0].identifierOrCriteria,
+                        item_type: SellItem.item_type.ERC721,
+                    }],
+                signature: orderSignature,
+                start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
+            },
+        });
+    }
+}
+
+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 ethers.utils.Interface(_abi);
+    }
+    static connect(address, signerOrProvider) {
+        return new ethers.Contract(address, _abi, signerOrProvider);
+    }
+}
+
+class ERC721Factory {
+    erc721;
+    constructor(contractAddress, provider) {
+        this.erc721 = ImmutableERC721Base__factory.connect(contractAddress, provider);
+    }
+    create() {
+        return new ERC721(this.erc721);
+    }
+}
+
+function getOrderComponentsFromMessage(orderMessage) {
+    const data = JSON.parse(orderMessage);
+    const orderComponents = data.message;
+    orderComponents.salt = ethers.BigNumber.from(orderComponents.salt).toHexString();
+    return orderComponents;
+}
+
+// Add 20% more gas than estimate to prevent out of gas errors
+// This can always be overwritten by the user signing the transaction
+async function prepareTransaction(transactionMethods) {
+    const transaction = await transactionMethods.buildTransaction();
+    transaction.gasLimit = await transactionMethods.estimateGas();
+    transaction.gasLimit = transaction.gasLimit
+        .add(transaction.gasLimit.div(5));
+    return transaction;
+}
+
+function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
+    const considerationItems = order.buy.map((buyItem) => ({
+        startAmount: buyItem.start_amount,
+        endAmount: buyItem.start_amount,
+        itemType: buyItem.item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
+        recipient: order.account_address,
+        token: buyItem.contract_address || ethers.constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    const fees = order.buy_fees.map((fee) => ({
+        startAmount: fee.amount,
+        endAmount: fee.amount,
+        itemType: order.buy[0].item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
+        recipient: fee.recipient,
+        token: order.buy[0].contract_address || ethers.constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    return {
+        conduitKey: ethers.constants.HashZero,
+        consideration: [...considerationItems, ...fees],
+        offer: order.sell.map((sellItem) => ({
+            startAmount: '1',
+            endAmount: '1',
+            itemType: constants.ItemType.ERC721,
+            token: sellItem.contract_address,
+            identifierOrCriteria: sellItem.token_id,
+        })),
+        counter,
+        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
+        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
+        salt: order.salt,
+        offerer: order.account_address,
+        zone: zoneAddress,
+        totalOriginalConsiderationItems: 2,
+        orderType: constants.OrderType.FULL_RESTRICTED,
+        zoneHash: ethers.constants.HashZero,
+    };
+}
+
+class Seaport {
+    seaport;
+    provider;
+    seaportContractAddress;
+    zoneContractAddress;
+    constructor(seaport, provider, seaportContractAddress, zoneContractAddress) {
+        this.seaport = seaport;
+        this.provider = provider;
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+    }
+    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
+        let approvalTransaction;
+        const approvalAction = actions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+        }
+        const createAction = actions
+            .find((action) => action.type === 'create');
+        if (!createAction) {
+            throw new Error('No create order action found');
+        }
+        const orderMessageToSign = await createAction.getMessageToSign();
+        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
+        return {
+            unsignedApprovalTransaction: approvalTransaction,
+            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
+            orderComponents,
+            orderHash: await this.seaport.getOrderHash(orderComponents),
+        };
+    }
+    async fulfilOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const { actions } = await this.seaport.fulfillOrders({
+            accountAddress: account,
+            fulfillOrderDetails: [{
+                    order: {
+                        parameters: orderComponents,
+                        signature: order.signature,
+                    },
+                }],
+        });
+        let approvalTransaction;
+        const approvalAction = actions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+        }
+        const fulfillmentAction = actions
+            .find((action) => action.type === 'exchange');
+        if (!fulfillmentAction) {
+            throw new Error('No exchange action found');
+        }
+        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
+        return {
+            unsignedApprovalTransaction: approvalTransaction,
+            unsignedFulfillmentTransaction: fulfillmentTransaction,
+        };
+    }
+    async cancelOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const cancellationTransaction = await this.seaport.cancelOrders([orderComponents], account);
+        return prepareTransaction(cancellationTransaction);
+    }
+    async mapImmutableOrderToSeaportOrderComponents(order) {
+        const counterForOfferer = await this.seaport.getCounter(order.account_address);
+        return mapImmutableOrderToSeaportOrderComponents(order, counterForOfferer.toString(), this.zoneContractAddress);
+    }
+    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        return this.seaport.createOrder({
+            allowPartialFills: false,
+            offer: [
+                {
+                    itemType: constants.ItemType.ERC721,
+                    token: listingItem.contractAddress,
+                    identifier: listingItem.tokenId,
+                },
+            ],
+            consideration: [
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: considerationItem.amount,
+                    recipient: offerer,
+                },
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: royaltyInfo.amountRequired,
+                    recipient: royaltyInfo.recipient,
+                },
+            ],
+            startTime: (orderStart.getTime() / 1000).toFixed(0),
+            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
+            zone: this.zoneContractAddress,
+            restrictedByZone: true,
+        }, offerer);
+    }
+    async getTypedDataFromOrderComponents(orderComponents) {
+        const { chainId } = await this.provider.getNetwork();
+        const domainData = {
+            name: constants.SEAPORT_CONTRACT_NAME,
+            version: constants.SEAPORT_CONTRACT_VERSION_V1_4,
+            chainId,
+            verifyingContract: this.seaportContractAddress,
+        };
+        return {
+            domain: domainData,
+            types: constants.EIP_712_ORDER_TYPE,
+            value: orderComponents,
+        };
+    }
+}
+
+class SeaportFactory {
+    seaportContractAddress;
+    zoneContractAddress;
+    provider;
+    seaport;
+    constructor(seaportContractAddress, zoneContractAddress, provider) {
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+        this.provider = provider;
+        this.seaport = new seaportJs.Seaport(provider, {
+            seaportVersion: '1.4',
+            balanceAndApprovalChecksOnOrderCreation: true,
+            overrides: {
+                contractAddress: seaportContractAddress,
+            },
+        });
+    }
+    create() {
+        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
+    }
+}
+
+/**
+ * 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();
     }
-    async logout() {
-        return this.authManager.logout();
+    /**
+     * Get an order by ID
+     * @param {string} orderId - The orderId to find.
+     * @return {Order} The returned order.
+     */
+    getOrder(orderId) {
+        return this.apiClient.getOrder(orderId);
     }
-    async getUserInfo() {
-        const user = await this.authManager.getUser();
-        return user?.profile;
+    /**
+     * 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));
     }
-    async getIdToken() {
-        const user = await this.authManager.getUser();
-        return user?.idToken;
+    /**
+     * 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);
     }
-    async getAccessToken() {
-        const user = await this.authManager.getUser();
-        return user?.accessToken;
+    /**
+     * 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);
     }
-    async registerUser(userAdminKeySigner, starkSigner, jwt) {
-        await registerPassport({
-            ethSigner: userAdminKeySigner,
-            starkSigner,
-            usersApi: this.immutableXClient.usersApi,
-        }, jwt);
-        const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
-        if (!updatedUser) {
-            throw new PassportError('Failed to get refresh token', PassportErrorType.REFRESH_TOKEN_ERROR);
+    /**
+     * 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}`);
         }
-        return updatedUser;
+        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$1 = 'orderbook';
+
 function isChainValid(chainID, config) {
     return chainID === config.ethConfiguration.chainID;
 }
 async function validateChain(signer, config) {
     const chainID = await signer.getChainId();
-    if (!isChainValid(chainID, config))
+    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, }) {
@@ -1549,17 +3385,15 @@ async function batchTransfer({ signers: { ethSigner, starkSigner }, request, con
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
     const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
-    const signableRequests = request.map((nftTransfer) => {
-        return {
-            amount: '1',
-            token: convertToSignableToken({
-                type: 'ERC721',
-                tokenId: nftTransfer.tokenId,
-                tokenAddress: nftTransfer.tokenAddress,
-            }),
-            receiver: nftTransfer.receiver,
-        };
-    });
+    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,
@@ -1573,6 +3407,8 @@ async function batchTransfer({ signers: { ethSigner, starkSigner }, request, con
     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,
@@ -1800,9 +3636,7 @@ async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token,
             config,
         });
     }
-    else {
-        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-    }
+    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
 async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
@@ -1819,7 +3653,7 @@ async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, st
     return ethSigner.sendTransaction(populatedTransaction);
 }
 function getMintingBlob(token) {
-    const id = token.data.id;
+    const { id } = token.data;
     const blueprint = token.data.blueprint || '';
     return encUtils__namespace.sanitizeHex(encUtils__namespace.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
@@ -1835,9 +3669,7 @@ async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token
     if (!isRegistered) {
         return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    else {
-        return executeWithdrawMintableERC721(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();
@@ -1862,14 +3694,12 @@ async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config
     if (!isRegistered) {
         return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
-    else {
-        return executeWithdrawERC721(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.tokenAddress;
-    const tokenId = token.tokenId;
+    const { tokenAddress } = token;
+    const { tokenId } = token;
     const imxConfig = config.immutableXConfig;
     const mintsApi = new coreSdk.MintsApi(imxConfig.apiConfiguration);
     return await mintsApi
@@ -1881,7 +3711,7 @@ async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token
         type: 'ERC721',
         data: {
             id: tokenId,
-            tokenAddress: tokenAddress,
+            tokenAddress,
             blueprint: mintableToken.data.blueprint,
         },
     }, config))
@@ -1915,9 +3745,7 @@ async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config,
     if (!isRegistered) {
         return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-    else {
-        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-    }
+    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
 async function prepareWithdrawal({ signers, withdrawal, config, }) {
@@ -1927,7 +3755,11 @@ async function prepareWithdrawal({ signers, withdrawal, config, }) {
         ...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 });
@@ -1985,6 +3817,18 @@ async function createTrade({ signers: { ethSigner, starkSigner }, request, confi
     return createTradeResponse.data;
 }
 
+async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
 async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
@@ -2022,23 +3866,21 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
     }
-    else {
-        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
-    }
+    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
 }
-async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+
+async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
     const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const coreContract = coreSdk.Contracts.Core.connect(config.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 });
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
 async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
@@ -2049,6 +3891,8 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     const usersApi = new coreSdk.UsersApi(apiConfiguration);
     // Get decimals for this specific ERC20
     const token = await tokensApi.getToken({ address: deposit.tokenAddress });
+    // TODO: remove once fixed
+    // eslint-disable-next-line radix
     const decimals = parseInt(token.data.decimals);
     const data = {
         decimals,
@@ -2090,23 +3934,14 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
     }
-    else {
-        return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
-    }
-}
-async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
+    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
 }
-async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+
+async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
     return ethSigner.sendTransaction(populatedTransaction);
 }
-
 async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
@@ -2157,18 +3992,18 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
         const coreContract = coreSdk.Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
-        // Note: proxy registration contract registerAndDepositNft method is not used as it currently fails erc721 transfer ownership check
+        // 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);
 }
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
 
+// 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 });
@@ -2306,7 +4141,10 @@ class GenericIMXProvider {
 }
 
 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) {
@@ -2323,6 +4161,8 @@ async function connectProvider(provider, chainID) {
 }
 
 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, }) {
@@ -2497,9 +4337,6 @@ const withProviderError = async (fn, customError) => {
 
 class MetaMaskIMXProvider extends GenericIMXProvider {
     static imxSigner;
-    constructor(config, ethSigner, starkSigner) {
-        super(config, ethSigner, starkSigner);
-    }
     static async connect(config) {
         return await withProviderError(async () => {
             const metaMaskProvider = await connect$1({
@@ -2521,9 +4358,7 @@ class MetaMaskIMXProvider extends GenericIMXProvider {
         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 () => {
-            return await this.imxSigner.signMessage(message);
-        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
+        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
     }
 }
 
@@ -2536,6 +4371,8 @@ class ProviderConfiguration {
             this.immutableXConfig = overrides.immutableXConfig;
         }
         else {
+            // TODO: remove once a sensible default is chosen
+            // eslint-disable-next-line default-case
             switch (baseConfig.environment) {
                 case exports.Environment.SANDBOX: {
                     this.immutableXConfig = coreSdk.Config.SANDBOX;
@@ -2615,6 +4452,14 @@ const $762782b6c862d954$export$db5daa1b5156ccfe = [
 ];
 
 
+
+const $bc2bfebf768286d3$export$6a2ba3c3bd042990 = {
+    baseConfig: {
+        environment: (exports.Environment).SANDBOX
+    }
+};
+
+
 exports.ConnectionProviders = void 0;
 (function(ConnectionProviders) {
     ConnectionProviders["METAMASK"] = "metamask";
@@ -2624,62 +4469,126 @@ exports.ConnectionProviders = void 0;
 exports.ChainId = void 0;
 (function(ChainId) {
     ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
-    ChainId[ChainId["GOERLI"] = 5] = "GOERLI";
-    ChainId[ChainId["POLYGON"] = 137] = "POLYGON";
+    ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
+    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13373] = "IMTBL_ZKEVM_DEVNET";
+    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13372] = "IMTBL_ZKEVM_TESTNET";
+    ChainId[ChainId["POLYGON_ZKEVM_TESTNET"] = 1442] = "POLYGON_ZKEVM_TESTNET";
+    ChainId[ChainId["POLYGON_ZKEVM"] = 137] = "POLYGON_ZKEVM";
 })(exports.ChainId || (exports.ChainId = {}));
-const $a47e48dd2c04791b$export$f61f4aaec62f6be9 = {
-    [exports.ChainId.ETHEREUM]: {
-        chainIdHex: "0x1",
-        chainName: "Ethereum",
-        rpcUrls: [
-            "https://mainnet.infura.io/v3/"
-        ],
-        nativeCurrency: {
-            name: "Ethereum",
-            symbol: "ETH",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://etherscan.io/"
-        ]
-    },
-    [exports.ChainId.GOERLI]: {
-        chainIdHex: "0x5",
-        chainName: "Goerli",
-        rpcUrls: [
-            "https://goerli.infura.io/v3/"
-        ],
-        nativeCurrency: {
-            name: "Goerli Eth",
-            symbol: "ETH",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://goerli.etherscan.io/"
-        ]
-    },
-    [exports.ChainId.POLYGON]: {
-        chainIdHex: "0x89",
-        chainName: "Polygon",
-        rpcUrls: [
-            "https://polygon-rpc.com"
-        ],
-        nativeCurrency: {
-            name: "MATIC",
-            symbol: "MATIC",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://polygonscan.com/"
-        ]
-    }
-};
+const $a47e48dd2c04791b$export$6f24f3cef7d501c4 = new Map([
+    [
+        exports.ChainId.ETHEREUM,
+        {
+            chainIdHex: "0x1",
+            chainName: "Ethereum",
+            rpcUrls: [
+                "https://mainnet.infura.io/v3/"
+            ],
+            nativeCurrency: {
+                name: "Ethereum",
+                symbol: "ETH",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://etherscan.io/"
+            ]
+        }
+    ],
+    [
+        exports.ChainId.IMTBL_ZKEVM_TESTNET,
+        {
+            chainIdHex: "0x343C",
+            chainName: "Immutable zkEVM Testnet",
+            rpcUrls: [
+                "https://zkevm-rpc.sandbox.x.immutable.com"
+            ],
+            nativeCurrency: {
+                name: "IMX",
+                symbol: "IMX",
+                decimals: 18
+            }
+        }
+    ],
+    [
+        exports.ChainId.POLYGON_ZKEVM,
+        {
+            chainIdHex: "0x89",
+            chainName: "Polygon zkEVM",
+            rpcUrls: [
+                "https://polygon-rpc.com"
+            ],
+            nativeCurrency: {
+                name: "MATIC",
+                symbol: "MATIC",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://polygonscan.com/"
+            ]
+        }
+    ]
+]);
+const $a47e48dd2c04791b$export$3e81fc0987227f10 = new Map([
+    [
+        exports.ChainId.SEPOLIA,
+        {
+            chainIdHex: "0xaa36a7",
+            chainName: "Sepolia",
+            rpcUrls: [
+                "https://sepolia.infura.io/v3/"
+            ],
+            nativeCurrency: {
+                name: "Sep Eth",
+                symbol: "ETH",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://sepolia.etherscan.io/"
+            ]
+        }
+    ],
+    [
+        exports.ChainId.IMTBL_ZKEVM_DEVNET,
+        {
+            chainIdHex: "0x343D",
+            chainName: "Immutable zkEVM Devnet",
+            rpcUrls: [
+                "https://zkevm-rpc.dev.x.immutable.com/"
+            ],
+            nativeCurrency: {
+                name: "IMX",
+                symbol: "IMX",
+                decimals: 18
+            }
+        }
+    ],
+    [
+        exports.ChainId.POLYGON_ZKEVM_TESTNET,
+        {
+            chainIdHex: "0x5A2",
+            chainName: "Polygon zkEVM Testnet",
+            rpcUrls: [
+                "https://rpc.public.zkevm-test.net"
+            ],
+            nativeCurrency: {
+                name: "MATIC",
+                symbol: "MATIC",
+                decimals: 18
+            },
+            blockExplorerUrls: [
+                "https://testnet-zkevm.polygonscan.com"
+            ]
+        }
+    ]
+]);
 exports.NetworkFilterTypes = void 0;
 (function(NetworkFilterTypes) {
     NetworkFilterTypes["ALL"] = "all";
 })(exports.NetworkFilterTypes || (exports.NetworkFilterTypes = {}));
 
 
+// TODO: fix circular dependency
+// eslint-disable-next-line import/no-cycle
 exports.TokenFilterTypes = void 0;
 (function(TokenFilterTypes) {
     TokenFilterTypes["SWAP"] = "swap";
@@ -2690,12 +4599,15 @@ exports.TokenFilterTypes = void 0;
 
 
 
-const $4f91c5f280efe242$export$a130407f3423b97d = {
-    CHECK_CONNECTION: "eth_accounts",
-    CONNECT: "eth_requestAccounts",
-    ADD_NETWORK: "wallet_addEthereumChain",
-    SWITCH_NETWORK: "wallet_switchEthereumChain"
-};
+// TODO: fix circular dependency
+// eslint-disable-next-line import/no-cycle
+let $4f91c5f280efe242$export$35b06f0d33f57e26;
+(function(WalletAction) {
+    WalletAction["CHECK_CONNECTION"] = "eth_accounts";
+    WalletAction["CONNECT"] = "eth_requestAccounts";
+    WalletAction["ADD_NETWORK"] = "wallet_addEthereumChain";
+    WalletAction["SWITCH_NETWORK"] = "wallet_switchEthereumChain";
+})($4f91c5f280efe242$export$35b06f0d33f57e26 || ($4f91c5f280efe242$export$35b06f0d33f57e26 = {}));
 exports.WalletFilterTypes = void 0;
 (function(WalletFilterTypes) {
     WalletFilterTypes["ALL"] = "all";
@@ -2704,12 +4616,6 @@ exports.WalletFilterTypes = void 0;
 })(exports.WalletFilterTypes || (exports.WalletFilterTypes = {}));
 
 
-exports.SupportedFiatCurrencies = void 0;
-(function(SupportedFiatCurrencies) {
-    SupportedFiatCurrencies["USD"] = "USD";
-})(exports.SupportedFiatCurrencies || (exports.SupportedFiatCurrencies = {}));
-
-
 
 
 /**
@@ -2727,9 +4633,6 @@ exports.SupportedFiatCurrencies = void 0;
     CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
     CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
     CheckoutErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
-    CheckoutErrorType["FIAT_CONVERSION_ERROR"] = "FIAT_CONVERSION_ERROR";
-    CheckoutErrorType["TOKEN_NOT_SUPPORTED_ERROR"] = "TOKEN_NOT_SUPPORTED_ERROR";
-    CheckoutErrorType["FIAT_CURRENCY_NOT_SUPPORTED_ERROR"] = "FIAT_CURRENCY_NOT_SUPPORTED_ERROR";
 })(exports.CheckoutErrorType || (exports.CheckoutErrorType = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     constructor(message, type, data){
@@ -2769,6 +4672,24 @@ const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
 
 
 
+async function $c99672cf2294e839$var$getMetaMaskProvider() {
+    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>await (detectEthereumProvider)(), {
+        type: (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR
+    });
+    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR);
+    return new (providers.Web3Provider)(provider);
+}
+async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
+    let web3Provider = null;
+    switch(providerPreference){
+        case (exports.ConnectionProviders).METAMASK:
+            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
+            break;
+        default:
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
+    }
+    return web3Provider;
+}
 async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
     const provider = await $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference);
     if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
@@ -2777,12 +4698,12 @@ async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
     let accounts = [];
     try {
         accounts = await provider.provider.request({
-            method: (0, $4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
+            method: (0, $4f91c5f280efe242$export$35b06f0d33f57e26).CHECK_CONNECTION,
             params: []
         });
     } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Check wallet connection request failed`, (exports.CheckoutErrorType).PROVIDER_REQUEST_FAILED_ERROR, {
-            rpcMethod: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Check wallet connection request failed", (exports.CheckoutErrorType).PROVIDER_REQUEST_FAILED_ERROR, {
+            rpcMethod: ($4f91c5f280efe242$export$35b06f0d33f57e26).CHECK_CONNECTION
         });
     }
     // accounts[0] will have the active account if connected.
@@ -2799,7 +4720,7 @@ async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
         });
         // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
         await web3Provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
+            method: ($4f91c5f280efe242$export$35b06f0d33f57e26).CONNECT,
             params: []
         });
     }, {
@@ -2807,43 +4728,57 @@ async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
     });
     return web3Provider;
 }
-async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
-    let web3Provider = null;
-    switch(providerPreference){
-        case (exports.ConnectionProviders).METAMASK:
-            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
-            break;
-        default:
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
-    }
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getMetaMaskProvider() {
-    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        return await (detectEthereumProvider)();
-    }, {
-        type: (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR
-    });
-    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR);
-    return new (providers.Web3Provider)(provider);
-}
 
 
 var $497c134ecbc8a50f$exports = {};
-$497c134ecbc8a50f$exports = JSON.parse('[{"chainId":1},{"chainId":137}]');
+$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)
-async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
+// 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 (!Object.values((exports.ChainId)).includes(network.chainId)) // return empty details
+        if (!Array.from(networkMap.keys()).includes(network.chainId)) // return empty details
         return {
             chainId: network.chainId,
             name: network.name,
             isSupported: false
         };
-        const chainIdNetworkInfo = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[network.chainId];
+        const chainIdNetworkInfo = networkMap.get(network.chainId);
         return {
             name: chainIdNetworkInfo.chainName,
             chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
@@ -2854,18 +4789,20 @@ async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
         type: (exports.CheckoutErrorType).GET_NETWORK_INFO_ERROR
     });
 }
-async function $de192de6ef100f9f$export$b827d9418aeb5dbd(providerPreference, provider, chainId) {
+async function $de192de6ef100f9f$export$b827d9418aeb5dbd(config, providerPreference, provider, chainId) {
     let currentProvider = provider;
+    const { networkMap: networkMap  } = config;
     if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
     if (!currentProvider || !currentProvider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
-        details: `Unsupported provider`
+        details: "Unsupported provider"
     });
     // WT-1146 - Refer to the README in this folder for explantion on the switch network flow
     try {
-        await $de192de6ef100f9f$var$switchNetworkInWallet(currentProvider, chainId);
+        await $de192de6ef100f9f$var$switchNetworkInWallet(networkMap, currentProvider, chainId);
     } catch (err) {
         if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
-            await $de192de6ef100f9f$var$addNetworkToWallet(currentProvider, chainId);
+            await $de192de6ef100f9f$var$addNetworkToWallet(networkMap, currentProvider, chainId);
+        // eslint-disable-next-line @typescript-eslint/no-shadow
         } catch (err) {
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled add network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
         }
@@ -2878,17 +4815,18 @@ async function $de192de6ef100f9f$export$b827d9418aeb5dbd(providerPreference, pro
     throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
     // we can assume that if the above succeeds then user has successfully
     // switched to the network specified
-    const newNetwork = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId];
+    const newNetwork = networkMap.get(chainId);
     return {
         network: {
-            name: newNetwork.chainName,
-            chainId: parseInt(newNetwork.chainIdHex, 16),
-            nativeCurrency: newNetwork.nativeCurrency
+            name: newNetwork?.chainName,
+            chainId: parseInt(newNetwork?.chainIdHex ?? "", 16),
+            nativeCurrency: newNetwork?.nativeCurrency
         },
         provider: currentProvider
     };
 }
-async function $de192de6ef100f9f$export$3043f6442a9ef563({ type: type = (exports.NetworkFilterTypes).ALL , exclude: exclude  }) {
+async function $de192de6ef100f9f$export$3043f6442a9ef563(config, { type: type = (exports.NetworkFilterTypes).ALL , exclude: exclude  }) {
+    const { networkMap: networkMap  } = config;
     const list = ((/*@__PURE__*/$parcel$interopDefault($497c134ecbc8a50f$exports))).filter((network)=>{
         const allowAllTokens = type === (exports.NetworkFilterTypes).ALL;
         const networkNotExcluded = !(exclude || []).map((exc)=>exc.chainId).includes(network.chainId);
@@ -2896,8 +4834,8 @@ async function $de192de6ef100f9f$export$3043f6442a9ef563({ type: type = (exports
     });
     const allowedNetworks = [];
     list.forEach((element)=>{
-        const newNetwork = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[element.chainId];
-        allowedNetworks.push({
+        const newNetwork = networkMap.get(element.chainId);
+        if (newNetwork) allowedNetworks.push({
             name: newNetwork.chainName,
             chainId: parseInt(newNetwork.chainIdHex, 16),
             nativeCurrency: newNetwork.nativeCurrency,
@@ -2908,64 +4846,35 @@ async function $de192de6ef100f9f$export$3043f6442a9ef563({ type: type = (exports
         networks: allowedNetworks
     };
 }
-// 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
-async function $de192de6ef100f9f$var$switchNetworkInWallet(provider, chainId) {
-    if (provider.provider?.request) return await provider.provider.request({
-        method: ($4f91c5f280efe242$export$a130407f3423b97d).SWITCH_NETWORK,
-        params: [
-            {
-                chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex
-            }
-        ]
-    });
-}
-async function $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId) {
-    if (provider.provider?.request) {
-        const addNetwork = {
-            chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex,
-            chainName: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainName,
-            rpcUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].rpcUrls,
-            nativeCurrency: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].nativeCurrency,
-            blockExplorerUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].blockExplorerUrls
-        };
-        return await provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).ADD_NETWORK,
-            params: [
-                addNetwork
-            ]
-        });
-    }
-}
 
 
 
 
 
 var $cda6003506e4182e$exports = {};
-$cda6003506e4182e$exports = JSON.parse("[{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":137,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"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 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"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\",\"chainId\":1,\"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\"]},{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":1,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"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 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"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\",\"chainId\":5,\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x1facdd0165489f373255a90304650e15481b2c85\",\"chainId\":5,\"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\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Swap Coin\",\"symbol\":\"SWC\",\"decimals\":18,\"tokenFeatures\":[\"swap\",\"fakeFeature\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Bridge Coin\",\"symbol\":\"BDC\",\"decimals\":18,\"tokenFeatures\":[\"bridge\",\"fakeFeature\"]}]");
+$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 = function({ type: type , chainId: chainId , exclude: exclude  }) {
-    return ((/*@__PURE__*/$parcel$interopDefault($cda6003506e4182e$exports))).filter((token)=>{
+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 chainIdMatches = token.chainId === chainId;
         const tokenNotExcluded = !exclude?.map((excludeToken)=>excludeToken.address).includes(token.address || "");
         const allowAllTokens = type === (exports.TokenFilterTypes).ALL;
         const tokenAllowedForType = token.tokenFeatures.includes(type);
         return (skipChainIdCheck || chainIdMatches) && tokenNotExcluded && (allowAllTokens || tokenAllowedForType);
     });
-};
-const $efe60cea83bfc4e8$export$473cec51305fdae8 = async function({ type: type = (exports.TokenFilterTypes).ALL , chainId: chainId , exclude: exclude  }) {
-    // todo:For API call, use the CheckoutError with errorType:API_CALL_ERROR?? or any other
+const $efe60cea83bfc4e8$export$473cec51305fdae8 = async ({ type: type = (exports.TokenFilterTypes).ALL , chainId: chainId , exclude: exclude  })=>{
     const filteredTokenList = $efe60cea83bfc4e8$var$filterTokenList({
         type: type,
         chainId: chainId,
         exclude: exclude
-    }).map((token)=>{
-        const { chainId: chainId , tokenFeatures: tokenFeatures , ...tokenInfo } = token;
-        return tokenInfo;
-    });
+    }).map((token)=>({
+            name: token.name,
+            symbol: token.symbol,
+            decimals: token.decimals,
+            address: token.address,
+            icon: token.icon
+        }));
     return {
         tokens: filteredTokenList
     };
@@ -2974,9 +4883,8 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async function({ type: type =
 
 
 
-const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (provider, walletAddress)=>{
-    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(provider);
+const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (config, provider, walletAddress)=>await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(config, provider);
         if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR, {
             chainName: networkInfo.name
         });
@@ -2989,7 +4897,6 @@ const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (provider, walletAddress
     }, {
         type: (exports.CheckoutErrorType).GET_BALANCE_ERROR
     });
-};
 async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, contractAddress) {
     return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
         const contract = new (ethers.Contract)(contractAddress, JSON.stringify(($762782b6c862d954$export$db5daa1b5156ccfe)), provider);
@@ -3012,7 +4919,7 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress
         type: (exports.CheckoutErrorType).GET_ERC20_BALANCE_ERROR
     });
 }
-const $1564e43dde50bb61$export$fee49741664a4d7e = async (provider, walletAddress, chainId)=>{
+const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, provider, walletAddress, chainId)=>{
     if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`ChainId ${chainId} is not supported`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
     if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR);
     const tokenList = await ($efe60cea83bfc4e8$export$473cec51305fdae8)({
@@ -3020,7 +4927,7 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (provider, walletAddress
         chainId: chainId
     });
     const allBalancePromises = [];
-    allBalancePromises.push($1564e43dde50bb61$export$df96cd8d56be0ab1(provider, walletAddress));
+    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);
@@ -3078,13 +4985,39 @@ const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (params)=>{
 
 
 
+
+
+
+class $4013c5c91bb535f6$export$47a4ed4a38b9eecf extends Error {
+    constructor(message){
+        super(message);
+        this.message = message;
+    }
+}
+class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
+    constructor(config){
+        // validate input
+        if (!Object.values((exports.Environment)).includes(config.baseConfig.environment)) throw new $4013c5c91bb535f6$export$47a4ed4a38b9eecf("Invalid checkout configuration of environment");
+        this.environment = config.baseConfig.environment;
+        this.networkMap = config.baseConfig.environment === (exports.Environment).PRODUCTION ? ($a47e48dd2c04791b$export$6f24f3cef7d501c4) : ($a47e48dd2c04791b$export$3e81fc0987227f10);
+    }
+}
+
+
+
+
 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.
+   * 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}
-   */ async checkIsWalletConnected(params) {
+   */ // eslint-disable-next-line class-methods-use-this
+    async checkIsWalletConnected(params) {
         return $c99672cf2294e839$export$2d040992269b4717(params.providerPreference);
     }
     /**
@@ -3095,7 +5028,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    */ async connect(params) {
         this.providerPreference = params.providerPreference;
         const provider = await $c99672cf2294e839$export$fba2f6c3656e07c1(params);
-        const networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider);
+        const networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(this.config, provider);
         return {
             provider: provider,
             network: networkInfo
@@ -3107,25 +5040,28 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @returns The new network information.
    * @throws {@link ErrorType}
    */ async switchNetwork(params) {
-        if (!this.providerPreference) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`connect should be called before switchNetwork to set the provider preference`, (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
-        return await $de192de6ef100f9f$export$b827d9418aeb5dbd(this.providerPreference, params.provider, params.chainId);
+        if (!this.providerPreference) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("connect should be called before switchNetwork to set the provider preference", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
+        return await $de192de6ef100f9f$export$b827d9418aeb5dbd(this.config, this.providerPreference, params.provider, params.chainId);
     }
     /**
-   * Fetch the balance of the native token of the current connected network or, if a contract address is provided, it will return the balance of that ERC20 token. For example, if the wallet is connected to the Ethereum Mainnet then the function gets the wallet ETH L1 balance.
+   * 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(params.provider, params.walletAddress);
+        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.
+   * 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(params.provider, params.walletAddress, params.chainId);
+        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.
@@ -3133,14 +5069,15 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @returns List of networks.
    * @throws {@link ErrorType}
    */ async getNetworkAllowList(params) {
-        return await $de192de6ef100f9f$export$3043f6442a9ef563(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}
-   */ async getTokenAllowList(params) {
+   */ // eslint-disable-next-line class-methods-use-this
+    async getTokenAllowList(params) {
         return await $efe60cea83bfc4e8$export$473cec51305fdae8(params);
     }
     /**
@@ -3148,7 +5085,8 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @param {GetWalletAllowListParams} params - The necessary data required to fetch the list of allowed wallets.
    * @returns List of allowed wallets.
    * @throws {@link ErrorType}
-   */ async getWalletAllowList(params) {
+   */ // eslint-disable-next-line class-methods-use-this
+    async getWalletAllowList(params) {
         return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
     }
     /**
@@ -3158,7 +5096,8 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @throws {@link ErrorType}
    * @remarks
    * Further documenation can be found at [MetaMask | Sending Transactions](https://docs.metamask.io/guide/sending-transactions.html).
-   */ async sendTransaction(params) {
+   */ // eslint-disable-next-line class-methods-use-this
+    async sendTransaction(params) {
         return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
     }
     /**
@@ -3167,13 +5106,14 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @returns Network details.
    * @throws {@link ErrorType}
    */ async getNetworkInfo(params) {
-        return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(params.provider);
+        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", () => exports.IMTBLWidgetEvents);
@@ -3212,6 +5152,7 @@ exports.WalletEventType = void 0;
     WalletEventType["REQUEST_SWAP"] = "request-swap";
     WalletEventType["REQUEST_BRIDGE"] = "request-bridge";
     WalletEventType["REQUEST_ONRAMP"] = "request-onramp";
+    WalletEventType["DISCONNECT_WALLET"] = "disconnect-wallet";
 })(exports.WalletEventType || (exports.WalletEventType = {}));
 
 
@@ -3226,6 +5167,7 @@ $parcel$export($53d219e7f6bf0cd6$exports, "SwapEventType", () => exports.SwapEve
 (function(SwapEventType) {
     SwapEventType["SUCCESS"] = "success";
     SwapEventType["FAILURE"] = "failure";
+    SwapEventType["CLOSE_WIDGET"] = "close-widget";
 })(exports.SwapEventType || (exports.SwapEventType = {}));
 
 
@@ -3265,21 +5207,23 @@ var $66ceef112c0ee49e$exports = {};
 $parcel$export($66ceef112c0ee49e$exports, "OnRampEventType", () => exports.OnRampEventType);
 exports.OnRampEventType = void 0;
 exports.OnRampEventType || (exports.OnRampEventType = {});
-
+/* eslint-disable @typescript-eslint/naming-convention */ 
 
 var $14d7a2bbb79e0dae$exports = {};
 
 $parcel$export($14d7a2bbb79e0dae$exports, "Network", () => exports.Network);
 $parcel$export($14d7a2bbb79e0dae$exports, "WidgetTheme", () => exports.WidgetTheme);
-$parcel$export($14d7a2bbb79e0dae$exports, "WidgetConnectionProviders", () => exports.WidgetConnectionProviders);
 $parcel$export($14d7a2bbb79e0dae$exports, "CheckoutWidgetTagNames", () => exports.CheckoutWidgetTagNames);
 /**
  * Enum representing the networks supported by Checkout.
  */ exports.Network = void 0;
 (function(Network) {
     Network["ETHEREUM"] = "Ethereum";
-    Network["GOERLI"] = "Goerli";
-    Network["POLYGON"] = "Polygon";
+    Network["SEPOLIA"] = "Sepolia";
+    Network["IMTBL_ZKEVM_TESTNET"] = "Immutable zkEVM Testnet";
+    Network["IMTBL_ZKEVM_DEVNET"] = "Immutable zkEVM Devnet";
+    Network["POLYGON_ZKEVM_TESTNET"] = "Polygon zkEVM Testnet";
+    Network["POLYGON_ZKEVM"] = "Polygon zkEVM";
 })(exports.Network || (exports.Network = {}));
 exports.WidgetTheme = void 0;
 (function(WidgetTheme) {
@@ -3287,10 +5231,6 @@ exports.WidgetTheme = void 0;
     WidgetTheme["DARK"] = "dark";
     WidgetTheme["CUSTOM"] = "custom";
 })(exports.WidgetTheme || (exports.WidgetTheme = {}));
-exports.WidgetConnectionProviders = void 0;
-(function(WidgetConnectionProviders) {
-    WidgetConnectionProviders["METAMASK"] = "metamask";
-})(exports.WidgetConnectionProviders || (exports.WidgetConnectionProviders = {}));
 exports.CheckoutWidgetTagNames = void 0;
 (function(CheckoutWidgetTagNames) {
     CheckoutWidgetTagNames["CONNECT"] = "imtbl-connect";
@@ -3307,13 +5247,12 @@ var $1f969328e5988c99$exports = {};
 $parcel$export($1f969328e5988c99$exports, "BridgeReact", () => $1f969328e5988c99$export$30f61ebf204c69f6);
 
 
-
 function $1f969328e5988c99$export$30f61ebf204c69f6(props) {
     const { providerPreference: providerPreference , fromContractAddress: fromContractAddress , amount: amount , fromNetwork: fromNetwork  } = props;
     const config = window.ImtblCheckoutWidgetConfig;
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-bridge", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK,
+        widgetConfig: config,
+        providerPreference: providerPreference,
         fromContractAddress: fromContractAddress ?? "",
         fromNetwork: fromNetwork ?? "",
         amount: amount ?? ""
@@ -3326,13 +5265,12 @@ var $f22931ca9e2f35b6$exports = {};
 $parcel$export($f22931ca9e2f35b6$exports, "BuyReact", () => $f22931ca9e2f35b6$export$d13582032b79b401);
 
 
-
 function $f22931ca9e2f35b6$export$d13582032b79b401(props) {
     const { providerPreference: providerPreference , orderId: orderId  } = props;
     const config = window.ImtblCheckoutWidgetConfig;
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-buy", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK,
+        widgetConfig: config,
+        providerPreference: providerPreference,
         orderId: orderId
     });
 }
@@ -3343,13 +5281,12 @@ var $f2083cd30e2f5c56$exports = {};
 $parcel$export($f2083cd30e2f5c56$exports, "ConnectReact", () => $f2083cd30e2f5c56$export$49d62957f420a1e2);
 
 
-
 function $f2083cd30e2f5c56$export$49d62957f420a1e2(props) {
     const { providerPreference: providerPreference  } = props;
     const config = window.ImtblCheckoutWidgetConfig;
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-connect", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK
+        widgetConfig: config,
+        providerPreference: providerPreference ?? "metamask"
     });
 }
 
@@ -3357,15 +5294,14 @@ function $f2083cd30e2f5c56$export$49d62957f420a1e2(props) {
 var $a4fbb8e3a6aeff58$exports = {};
 
 $parcel$export($a4fbb8e3a6aeff58$exports, "SwapReact", () => $a4fbb8e3a6aeff58$export$971e031379577f4);
-
-
+/* eslint-disable max-len */ 
 
 function $a4fbb8e3a6aeff58$export$971e031379577f4(props) {
     const { providerPreference: providerPreference , fromContractAddress: fromContractAddress , amount: amount , toContractAddress: toContractAddress  } = props;
     const config = window.ImtblCheckoutWidgetConfig;
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-swap", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK,
+        widgetConfig: config,
+        providerPreference: providerPreference,
         fromContractAddress: fromContractAddress ?? "",
         toContractAddress: toContractAddress ?? "",
         amount: amount ?? ""
@@ -3378,18 +5314,13 @@ var $89d55ace0f8f1c07$exports = {};
 $parcel$export($89d55ace0f8f1c07$exports, "WalletReact", () => $89d55ace0f8f1c07$export$ceaac94f34dba154);
 
 
-
 function $89d55ace0f8f1c07$export$ceaac94f34dba154(props) {
-    const { providerPreference: providerPreference , isBridgeEnabled: isBridgeEnabled , isOnRampEnabled: isOnRampEnabled , isSwapEnabled: isSwapEnabled  } = props;
+    const { providerPreference: providerPreference , useConnectWidget: useConnectWidget  } = props;
     const config = window.ImtblCheckoutWidgetConfig;
-    // isOnRampEnabled, isBridgeEnabled, isSwapEnabled is a boolean type for better devExp
-    // converting them to string for compatible webComponent properties
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-wallet", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK,
-        isBridgeEnabled: isBridgeEnabled?.toString(),
-        isSwapEnabled: isSwapEnabled?.toString(),
-        isOnRampEnabled: isOnRampEnabled?.toString()
+        widgetConfig: config,
+        useConnectWidget: useConnectWidget?.toString(),
+        providerPreference: providerPreference ?? "metamask"
     });
 }
 
@@ -3401,31 +5332,33 @@ $parcel$export($d087956fd1002f80$exports, "ExampleReact", () => $d087956fd1002f8
 
 
 function $d087956fd1002f80$export$fa517eee6594d26c(props) {
-    const { providerPreference: providerPreference , fromContractAddress: fromContractAddress , amount: amount , fromNetwork: fromNetwork  } = props;
-    const config = window.ImtblCheckoutWidgetConfig;
+    const { providerPreference: // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    providerPreference , environment: environment , theme: theme  } = props;
     return /*#__PURE__*/ (jsxRuntime.jsx)("imtbl-example", {
-        providerPreference: providerPreference ?? (exports.WidgetConnectionProviders).METAMASK,
-        theme: config.theme ?? (exports.WidgetTheme).DARK
+        environment: environment ?? (exports.Environment).SANDBOX,
+        theme: theme ?? "dark",
+        providerPreference: providerPreference
     });
 }
 
 
-var $fa90757d8d7a0962$exports = {};
+var $430e3eda76fa4d5f$exports = {};
 
-$parcel$export($fa90757d8d7a0962$exports, "CheckoutWidgets", () => $fa90757d8d7a0962$export$af210a0808087845);
-$parcel$export($fa90757d8d7a0962$exports, "UpdateConfig", () => $fa90757d8d7a0962$export$bf1548ba7e61c17f);
-$parcel$export($fa90757d8d7a0962$exports, "SetProvider", () => $fa90757d8d7a0962$export$931068bc678f0d73);
-function $fa90757d8d7a0962$export$af210a0808087845(config) {
-    var checkoutWidgetJS = document.createElement("script");
+$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 = config;
+    window.ImtblCheckoutWidgetConfig = JSON.stringify(config);
 }
-function $fa90757d8d7a0962$export$bf1548ba7e61c17f(config) {
-    window.ImtblCheckoutWidgetConfig = config;
+function $430e3eda76fa4d5f$export$bf1548ba7e61c17f(config) {
+    window.ImtblCheckoutWidgetConfig = JSON.stringify(config);
 }
-function $fa90757d8d7a0962$export$931068bc678f0d73(tagName, provider) {
+function $430e3eda76fa4d5f$export$931068bc678f0d73(tagName, provider) {
     if (!provider) {
+        // eslint-disable-next-line no-console
         console.error("no provider parsed");
         return;
     }
@@ -3442,6 +5375,7 @@ function $fa90757d8d7a0962$export$931068bc678f0d73(tagName, provider) {
             attempts++;
             if (attempts >= maxAttempts) {
                 window.clearInterval(timer);
+                // eslint-disable-next-line no-console
                 console.error("failed to set the provider");
             }
         }
@@ -3458,20 +5392,23 @@ Object.defineProperty(exports, 'imxClientGenerateLegacyStarkPrivateKey', {
     enumerable: true,
     get: function () { return coreSdk.generateLegacyStarkPrivateKey; }
 });
+exports.guardian = guardian__namespace;
 exports.BridgeReact = $1f969328e5988c99$export$30f61ebf204c69f6;
 exports.BuyReact = $f22931ca9e2f35b6$export$d13582032b79b401;
 exports.Checkout = $a8cb37a3fc8eb863$export$1f60ba4ec72508a0;
-exports.CheckoutWidgets = $fa90757d8d7a0962$export$af210a0808087845;
+exports.CheckoutWidgets = $430e3eda76fa4d5f$export$af210a0808087845;
 exports.ConnectReact = $f2083cd30e2f5c56$export$49d62957f420a1e2;
 exports.ExampleReact = $d087956fd1002f80$export$fa517eee6594d26c;
 exports.GenericIMXProvider = GenericIMXProvider;
 exports.ImmutableConfiguration = ImmutableConfiguration;
 exports.ImmutableXClient = ImmutableXClient;
 exports.MetaMaskIMXProvider = MetaMaskIMXProvider;
+exports.Orderbook = Orderbook;
 exports.Passport = Passport;
 exports.PassportError = PassportError;
 exports.ProviderConfiguration = ProviderConfiguration;
-exports.SetProvider = $fa90757d8d7a0962$export$931068bc678f0d73;
+exports.SetProvider = $430e3eda76fa4d5f$export$931068bc678f0d73;
 exports.SwapReact = $a4fbb8e3a6aeff58$export$971e031379577f4;
-exports.UpdateConfig = $fa90757d8d7a0962$export$bf1548ba7e61c17f;
+exports.UpdateConfig = $430e3eda76fa4d5f$export$bf1548ba7e61c17f;
 exports.WalletReact = $89d55ace0f8f1c07$export$ceaac94f34dba154;
+exports.module = module$1;