@imtbl/sdk 0.6.0-alpha → 0.7.0-alpha.1

package/dist/checkout_sdk.js

@@ -1,4 +1,4 @@
-import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as BigNumber$2 } from 'ethers';
+import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as BigNumber$2, providers, constants } from 'ethers';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
 import $7v2Z6$metamaskdetectprovider from '@metamask/detect-provider';
 import { Token, TradeType, CurrencyAmount, Percent } from '@uniswap/sdk-core';
@@ -7,7 +7,9 @@ import { BigNumber as BigNumber$1 } from '@ethersproject/bignumber';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
 import { SwapRouter } from '@uniswap/router-sdk';
-import $7v2Z6$axios from 'axios';
+import axios from 'axios';
+import FormData from 'form-data';
+import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 
 var Environment$1;
 (function (Environment) {
@@ -13669,7 +13671,7 @@ class SecondaryFee__factory extends ContractFactory {
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-const _abi = [
+const _abi$4 = [
     {
         inputs: [],
         stateMutability: "nonpayable",
@@ -14665,7 +14667,7 @@ class UniswapV3Pool__factory extends ContractFactory {
             super(...args);
         }
         else {
-            super(_abi, _bytecode, args[0]);
+            super(_abi$4, _bytecode, args[0]);
         }
     }
     deploy(overrides) {
@@ -14681,12 +14683,12 @@ class UniswapV3Pool__factory extends ContractFactory {
         return super.connect(signer);
     }
     static bytecode = _bytecode;
-    static abi = _abi;
+    static abi = _abi$4;
     static createInterface() {
-        return new utils.Interface(_abi);
+        return new utils.Interface(_abi$4);
     }
     static connect(address, signerOrProvider) {
-        return new Contract$1(address, _abi, signerOrProvider);
+        return new Contract$1(address, _abi$4, signerOrProvider);
     }
 }
 
@@ -15412,109 +15414,2121 @@ class Exchange {
     }
 }
 
-/* eslint-disable class-methods-use-this */ 
+class BaseHttpRequest {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}
 
-const $762782b6c862d954$export$db5daa1b5156ccfe = [
-    {
-        constant: true,
-        inputs: [],
-        name: "name",
-        outputs: [
-            {
-                name: "",
-                type: "string"
+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();
+                }
             }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: "decimals",
-        outputs: [
-            {
-                name: "",
-                type: "uint8"
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
             }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                name: "_owner",
-                type: "address"
+        }
+        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 isSuccess = (status) => {
+    return status >= 200 && status < 300;
+};
+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);
+                });
             }
-        ],
-        name: "balanceOf",
-        outputs: [
-            {
-                name: "balance",
-                type: "uint256"
+            else if (typeof value === 'object') {
+                Object.entries(value).forEach(([k, v]) => {
+                    process(`${key}[${k}]`, v);
+                });
             }
-        ],
-        payable: false,
-        type: "function"
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: "symbol",
-        outputs: [
-            {
-                name: "",
-                type: "string"
+            else {
+                append(key, value);
             }
-        ],
-        payable: false,
-        type: "function"
+        }
+    };
+    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, formData) => {
+    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 formHeaders = typeof formData?.getHeaders === 'function' && formData?.getHeaders() || {};
+    const headers = Object.entries({
+        Accept: 'application/json',
+        ...additionalHeaders,
+        ...options.headers,
+        ...formHeaders,
+    })
+        .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'] = options.body.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 headers;
+};
+const getRequestBody = (options) => {
+    if (options.body) {
+        return options.body;
+    }
+    return undefined;
+};
+const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+    const source = axios.CancelToken.source();
+    const requestConfig = {
+        url,
+        headers,
+        data: body ?? formData,
+        method: options.method,
+        withCredentials: config.WITH_CREDENTIALS,
+        cancelToken: source.token,
+    };
+    onCancel(() => source.cancel('The user aborted a request.'));
+    try {
+        return await axios.request(requestConfig);
+    }
+    catch (error) {
+        const axiosError = error;
+        if (axiosError.response) {
+            return axiosError.response;
+        }
+        throw error;
+    }
+};
+const getResponseHeader = (response, responseHeader) => {
+    if (responseHeader) {
+        const content = response.headers[responseHeader];
+        if (isString(content)) {
+            return content;
+        }
+    }
+    return undefined;
+};
+const getResponseBody = (response) => {
+    if (response.status !== 204) {
+        return response.data;
+    }
+    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');
+    }
+};
 /**
- * Enum representing different chain IDs.
- * @enum {number}
- * @property {number} IMTBL_ZKEVM_MAINNET - The chain ID for IMTBL ZKEVM Mainnet.
- * @property {number} IMTBL_ZKEVM_TESTNET - The chain ID for IMTBL ZKEVM Testnet.
- * @property {number} IMTBL_ZKEVM_DEVNET - The chain ID for IMTBL ZKEVM Devnet.
- * @property {number} ETHEREUM - The chain ID for Ethereum.
- * @property {number} SEPOLIA - The chain ID for Sepolia.
- */ var $0472f23319457bfb$export$c06e1e7429de6283;
-(function(ChainId) {
-    ChainId[ChainId["IMTBL_ZKEVM_MAINNET"] = 13371] = "IMTBL_ZKEVM_MAINNET";
-    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13472] = "IMTBL_ZKEVM_TESTNET";
-    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13433] = "IMTBL_ZKEVM_DEVNET";
-    ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
-    ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
-})($0472f23319457bfb$export$c06e1e7429de6283 || ($0472f23319457bfb$export$c06e1e7429de6283 = {}));
-var $0472f23319457bfb$export$b874c6b1dfe85e02;
-(function(ChainName) {
-    ChainName["ETHEREUM"] = "Ethereum";
-    ChainName["SEPOLIA"] = "Sepolia";
-    ChainName["IMTBL_ZKEVM_TESTNET"] = "Immutable zkEVM Test";
-    ChainName["IMTBL_ZKEVM_DEVNET"] = "Immutable zkEVM Dev";
-    ChainName["IMTBL_ZKEVM_MAINNET"] = "Immutable zkEVM";
-})($0472f23319457bfb$export$b874c6b1dfe85e02 || ($0472f23319457bfb$export$b874c6b1dfe85e02 = {}));
+ * 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, formData);
+            if (!onCancel.isCancelled) {
+                const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+                const responseBody = getResponseBody(response);
+                const responseHeader = getResponseHeader(response, options.responseHeader);
+                const result = {
+                    url,
+                    ok: isSuccess(response.status),
+                    status: response.status,
+                    statusText: response.statusText,
+                    body: responseHeader ?? responseBody,
+                };
+                catchErrorCodes(options, result);
+                resolve(result.body);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
 
+class AxiosHttpRequest 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 listings
+     * List all listings
+     * @returns ListListingsResult OK response.
+     * @throws ApiError
+     */
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, pageSize, sortBy, sortDirection, pageCursor, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/orders/listings',
+            path: {
+                'chain_name': chainName,
+            },
+            query: {
+                'status': status,
+                'sell_item_contract_address': sellItemContractAddress,
+                'buy_item_contract_address': buyItemContractAddress,
+                'sell_item_token_id': sellItemTokenId,
+                'page_size': pageSize,
+                'sort_by': sortBy,
+                'sort_direction': sortDirection,
+                'page_cursor': pageCursor,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
+     * @throws ApiError
+     */
+    createListing({ chainName, requestBody, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/v1/chains/{chain_name}/orders/listings',
+            path: {
+                'chain_name': chainName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
+     * @throws ApiError
+     */
+    getListing({ chainName, listingId, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/orders/listings/{listing_id}',
+            path: {
+                'chain_name': chainName,
+                'listing_id': listingId,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+}
 
+class OrderBookClient {
+    orders;
+    request;
+    constructor(config, HttpRequest = AxiosHttpRequest) {
+        this.request = new HttpRequest({
+            BASE: config?.BASE ?? 'https://api.dev.immutable.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 CreateOrderProtocolData;
+(function (CreateOrderProtocolData) {
+    (function (order_type) {
+        order_type["FULL_RESTRICTED"] = "FULL_RESTRICTED";
+    })(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 */
+/**
+ * The Order status
+ */
+var OrderStatus;
+(function (OrderStatus) {
+    OrderStatus["PENDING"] = "PENDING";
+    OrderStatus["ACTIVE"] = "ACTIVE";
+    OrderStatus["INACTIVE"] = "INACTIVE";
+    OrderStatus["FILLED"] = "FILLED";
+    OrderStatus["CANCELLED"] = "CANCELLED";
+    OrderStatus["EXPIRED"] = "EXPIRED";
+})(OrderStatus || (OrderStatus = {}));
+
+var TransactionPurpose;
+(function (TransactionPurpose) {
+    TransactionPurpose["APPROVAL"] = "APPROVAL";
+    TransactionPurpose["FULFILL_ORDER"] = "FULFILL_ORDER";
+})(TransactionPurpose || (TransactionPurpose = {}));
+var SignablePurpose;
+(function (SignablePurpose) {
+    SignablePurpose["CREATE_LISTING"] = "CREATE_LISTING";
+})(SignablePurpose || (SignablePurpose = {}));
+var ActionType;
+(function (ActionType) {
+    ActionType["TRANSACTION"] = "TRANSACTION";
+    ActionType["SIGNABLE"] = "SIGNABLE";
+})(ActionType || (ActionType = {}));
 
+/* eslint-disable */
+// TODO: Resolve these from seaport-js.
+// There is some bundling issue that is preventing this from working
+const SEAPORT_CONTRACT_NAME = 'ImmutableSeaport';
+const SEAPORT_CONTRACT_VERSION_V1_4 = '1.4';
+const SEAPORT_CONTRACT_VERSION_V1_5 = '1.5';
+const EIP_712_ORDER_TYPE = {
+    OrderComponents: [
+        { name: 'offerer', type: 'address' },
+        { name: 'zone', type: 'address' },
+        { name: 'offer', type: 'OfferItem[]' },
+        { name: 'consideration', type: 'ConsiderationItem[]' },
+        { name: 'orderType', type: 'uint8' },
+        { name: 'startTime', type: 'uint256' },
+        { name: 'endTime', type: 'uint256' },
+        { name: 'zoneHash', type: 'bytes32' },
+        { name: 'salt', type: 'uint256' },
+        { name: 'conduitKey', type: 'bytes32' },
+        { name: 'counter', type: 'uint256' },
+    ],
+    OfferItem: [
+        { name: 'itemType', type: 'uint8' },
+        { name: 'token', type: 'address' },
+        { name: 'identifierOrCriteria', type: 'uint256' },
+        { name: 'startAmount', type: 'uint256' },
+        { name: 'endAmount', type: 'uint256' },
+    ],
+    ConsiderationItem: [
+        { name: 'itemType', type: 'uint8' },
+        { name: 'token', type: 'address' },
+        { name: 'identifierOrCriteria', type: 'uint256' },
+        { name: 'startAmount', type: 'uint256' },
+        { name: 'endAmount', type: 'uint256' },
+        { name: 'recipient', type: 'address' },
+    ],
+};
+var OrderType;
+(function (OrderType) {
+    OrderType[OrderType["FULL_OPEN"] = 0] = "FULL_OPEN";
+    OrderType[OrderType["PARTIAL_OPEN"] = 1] = "PARTIAL_OPEN";
+    OrderType[OrderType["FULL_RESTRICTED"] = 2] = "FULL_RESTRICTED";
+    OrderType[OrderType["PARTIAL_RESTRICTED"] = 3] = "PARTIAL_RESTRICTED";
+})(OrderType || (OrderType = {}));
+var ItemType;
+(function (ItemType) {
+    ItemType[ItemType["NATIVE"] = 0] = "NATIVE";
+    ItemType[ItemType["ERC20"] = 1] = "ERC20";
+    ItemType[ItemType["ERC721"] = 2] = "ERC721";
+    ItemType[ItemType["ERC1155"] = 3] = "ERC1155";
+    ItemType[ItemType["ERC721_WITH_CRITERIA"] = 4] = "ERC721_WITH_CRITERIA";
+    ItemType[ItemType["ERC1155_WITH_CRITERIA"] = 5] = "ERC1155_WITH_CRITERIA";
+})(ItemType || (ItemType = {}));
+var Side;
+(function (Side) {
+    Side[Side["OFFER"] = 0] = "OFFER";
+    Side[Side["CONSIDERATION"] = 1] = "CONSIDERATION";
+})(Side || (Side = {}));
+var BasicOrderRouteType;
+(function (BasicOrderRouteType) {
+    BasicOrderRouteType[BasicOrderRouteType["ETH_TO_ERC721"] = 0] = "ETH_TO_ERC721";
+    BasicOrderRouteType[BasicOrderRouteType["ETH_TO_ERC1155"] = 1] = "ETH_TO_ERC1155";
+    BasicOrderRouteType[BasicOrderRouteType["ERC20_TO_ERC721"] = 2] = "ERC20_TO_ERC721";
+    BasicOrderRouteType[BasicOrderRouteType["ERC20_TO_ERC1155"] = 3] = "ERC20_TO_ERC1155";
+    BasicOrderRouteType[BasicOrderRouteType["ERC721_TO_ERC20"] = 4] = "ERC721_TO_ERC20";
+    BasicOrderRouteType[BasicOrderRouteType["ERC1155_TO_ERC20"] = 5] = "ERC1155_TO_ERC20";
+})(BasicOrderRouteType || (BasicOrderRouteType = {}));
+
+function getOrderComponentsFromMessage(orderMessage) {
+    const data = JSON.parse(orderMessage);
+    const orderComponents = data.message;
+    orderComponents.salt = BigNumber$2.from(orderComponents.salt).toHexString();
+    return orderComponents;
+}
 
-var $de275b98d2b651c3$export$788b1fd17f3dad84;
-(function(GasEstimateType) {
-    GasEstimateType["BRIDGE_TO_L2"] = "BRIDGE_TO_L2";
-    GasEstimateType["SWAP"] = "SWAP";
-})($de275b98d2b651c3$export$788b1fd17f3dad84 || ($de275b98d2b651c3$export$788b1fd17f3dad84 = {}));
+// Add 20% more gas than estimate to prevent out of gas errors
+// This can always be overwritten by the user signing the transaction
+function prepareTransaction(transactionMethods) {
+    return async () => {
+        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) => {
+        switch (buyItem.item_type) {
+            case 'NATIVE':
+                return {
+                    startAmount: buyItem.start_amount,
+                    endAmount: buyItem.start_amount,
+                    itemType: ItemType.NATIVE,
+                    recipient: order.account_address,
+                    token: constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+            case 'ERC20':
+                return {
+                    startAmount: buyItem.start_amount,
+                    endAmount: buyItem.start_amount,
+                    itemType: ItemType.ERC20,
+                    recipient: order.account_address,
+                    token: buyItem.contract_address || constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+            default: // ERC721
+                return {
+                    startAmount: '1',
+                    endAmount: '1',
+                    itemType: ItemType.ERC721,
+                    recipient: order.account_address,
+                    token: buyItem.contract_address || constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+        }
+    });
+    const fees = order.fees.map((fee) => ({
+        startAmount: fee.amount,
+        endAmount: fee.amount,
+        itemType: order.buy[0].item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
+        recipient: fee.recipient,
+        token: order.buy[0].item_type === 'ERC20'
+            ? order.buy[0].contract_address
+            : constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    return {
+        conduitKey: constants.HashZero,
+        consideration: [...considerationItems, ...fees],
+        offer: order.sell.map((sellItem) => {
+            const erc721Item = sellItem;
+            return {
+                startAmount: '1',
+                endAmount: '1',
+                itemType: ItemType.ERC721,
+                token: erc721Item.contract_address,
+                identifierOrCriteria: erc721Item.token_id,
+            };
+        }),
+        counter,
+        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
+        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
+        salt: order.salt,
+        offerer: order.account_address,
+        zone: zoneAddress,
+        totalOriginalConsiderationItems: 2,
+        orderType: OrderType.FULL_RESTRICTED,
+        zoneHash: constants.HashZero,
+    };
+}
 
-var $a47e48dd2c04791b$export$1f05a55fe0680cc7;
-(function(NetworkFilterTypes) {
-    NetworkFilterTypes["ALL"] = "all";
+class Seaport {
+    seaportLibFactory;
+    provider;
+    seaportContractAddress;
+    zoneContractAddress;
+    constructor(seaportLibFactory, provider, seaportContractAddress, zoneContractAddress) {
+        this.seaportLibFactory = seaportLibFactory;
+        this.provider = provider;
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+    }
+    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        const { actions: seaportActions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
+        const listingActions = [];
+        const approvalAction = seaportActions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            listingActions.push({
+                type: ActionType.TRANSACTION,
+                purpose: TransactionPurpose.APPROVAL,
+                buildTransaction: prepareTransaction(approvalAction.transactionMethods),
+            });
+        }
+        const createAction = seaportActions
+            .find((action) => action.type === 'create');
+        if (!createAction) {
+            throw new Error('No create order action found');
+        }
+        const orderMessageToSign = await createAction.getMessageToSign();
+        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
+        listingActions.push({
+            type: ActionType.SIGNABLE,
+            purpose: SignablePurpose.CREATE_LISTING,
+            message: await this.getTypedDataFromOrderComponents(orderComponents),
+        });
+        return {
+            actions: listingActions,
+            orderComponents,
+            orderHash: this.getSeaportLib().getOrderHash(orderComponents),
+        };
+    }
+    async fulfillOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const seaportLib = this.getSeaportLib(order);
+        const { actions: seaportActions } = await seaportLib.fulfillOrders({
+            accountAddress: account,
+            fulfillOrderDetails: [{
+                    order: {
+                        parameters: orderComponents,
+                        signature: order.signature,
+                    },
+                    extraData: order.protocol_data.operator_signature,
+                }],
+        });
+        const fulfillmentActions = [];
+        const approvalAction = seaportActions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            fulfillmentActions.push({
+                type: ActionType.TRANSACTION,
+                buildTransaction: prepareTransaction(approvalAction.transactionMethods),
+                purpose: TransactionPurpose.APPROVAL,
+            });
+        }
+        const fulfilOrderAction = seaportActions
+            .find((action) => action.type === 'exchange');
+        if (!fulfilOrderAction) {
+            throw new Error('No exchange action found');
+        }
+        fulfillmentActions.push({
+            type: ActionType.TRANSACTION,
+            buildTransaction: prepareTransaction(fulfilOrderAction.transactionMethods),
+            purpose: TransactionPurpose.FULFILL_ORDER,
+        });
+        return { actions: fulfillmentActions };
+    }
+    async cancelOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const seaportLib = this.getSeaportLib(order);
+        const cancellationTransaction = await seaportLib.cancelOrders([orderComponents], account);
+        return prepareTransaction(cancellationTransaction)();
+    }
+    mapImmutableOrderToSeaportOrderComponents(order) {
+        const orderCounter = order.protocol_data.counter;
+        return mapImmutableOrderToSeaportOrderComponents(order, orderCounter, this.zoneContractAddress);
+    }
+    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        const seaportLib = this.getSeaportLib();
+        return seaportLib.createOrder({
+            allowPartialFills: false,
+            offer: [
+                {
+                    itemType: ItemType.ERC721,
+                    token: listingItem.contractAddress,
+                    identifier: listingItem.tokenId,
+                },
+            ],
+            consideration: [
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: considerationItem.amount,
+                    recipient: offerer,
+                },
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: royaltyInfo.amountRequired,
+                    recipient: royaltyInfo.recipient,
+                },
+            ],
+            startTime: (orderStart.getTime() / 1000).toFixed(0),
+            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
+            zone: this.zoneContractAddress,
+            restrictedByZone: true,
+        }, offerer);
+    }
+    async getTypedDataFromOrderComponents(orderComponents) {
+        const { chainId } = await this.provider.getNetwork();
+        const domainData = {
+            name: SEAPORT_CONTRACT_NAME,
+            version: SEAPORT_CONTRACT_VERSION_V1_4,
+            chainId,
+            verifyingContract: this.seaportContractAddress,
+        };
+        return {
+            domain: domainData,
+            types: EIP_712_ORDER_TYPE,
+            value: orderComponents,
+        };
+    }
+    getSeaportLib(order) {
+        const seaportAddress = order?.protocol_data?.seaport_address ?? this.seaportContractAddress;
+        let seaportVersion = SEAPORT_CONTRACT_VERSION_V1_4;
+        if (order?.protocol_data?.seaport_version === SEAPORT_CONTRACT_VERSION_V1_5) {
+            seaportVersion = SEAPORT_CONTRACT_VERSION_V1_5;
+        }
+        return this.seaportLibFactory.create(seaportVersion, seaportAddress);
+    }
+}
+
+class ImmutableApiClient {
+    orderbookService;
+    chainName;
+    seaportAddress;
+    constructor(orderbookService, chainName, seaportAddress) {
+        this.orderbookService = orderbookService;
+        this.chainName = chainName;
+        this.seaportAddress = seaportAddress;
+    }
+    async getListing(listingId) {
+        return this.orderbookService.getListing({
+            chainName: this.chainName,
+            listingId,
+        });
+    }
+    async listListings(listOrderParams) {
+        return this.orderbookService.listListings({
+            chainName: this.chainName,
+            ...listOrderParams,
+        });
+    }
+    async createListing({ orderHash, orderComponents, orderSignature, }) {
+        if (orderComponents.offer.length !== 1) {
+            throw new Error('Only one item can be listed at a time');
+        }
+        if (Number(orderComponents.offer[0].itemType) !== ItemType.ERC721) {
+            throw new Error('Only ERC721 tokens can be listed');
+        }
+        const orderTypes = [
+            ...orderComponents.consideration.map((c) => c.itemType),
+        ];
+        const isSameConsiderationType = new Set(orderTypes).size === 1;
+        if (!isSameConsiderationType) {
+            throw new Error('All consideration items must be of the same type');
+        }
+        return this.orderbookService.createListing({
+            chainName: this.chainName,
+            requestBody: {
+                order_hash: orderHash,
+                account_address: orderComponents.offerer,
+                buy: [
+                    {
+                        item_type: Number(orderComponents.consideration[0].itemType)
+                            === ItemType.NATIVE
+                            ? 'NATIVE'
+                            : 'ERC20',
+                        start_amount: orderComponents.consideration[0].startAmount,
+                        contract_address: orderComponents.consideration[0].token,
+                    },
+                ],
+                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_RESTRICTED,
+                    zone_address: orderComponents.zone,
+                    seaport_address: this.seaportAddress,
+                    seaport_version: SEAPORT_CONTRACT_VERSION_V1_4,
+                    counter: orderComponents.counter.toString(),
+                },
+                salt: orderComponents.salt,
+                sell: [
+                    {
+                        contract_address: orderComponents.offer[0].token,
+                        token_id: orderComponents.offer[0].identifierOrCriteria,
+                        item_type: 'ERC721',
+                    },
+                ],
+                signature: orderSignature,
+                start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
+            },
+        });
+    }
+}
+
+class ImmutableApiClientFactory {
+    chainName;
+    seaportAddress;
+    orderbookClient;
+    constructor(apiEndpoint, chainName, seaportAddress) {
+        this.chainName = chainName;
+        this.seaportAddress = seaportAddress;
+        this.orderbookClient = new OrderBookClient({
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            BASE: apiEndpoint,
+        });
+    }
+    create() {
+        return new ImmutableApiClient(this.orderbookClient.orders, this.chainName, this.seaportAddress);
+    }
+}
+
+const TESTNET_CHAIN_NAME = 'imtbl-zkevm-testnet';
+const MAINNET_CHAIN_NAME = 'imtbl-zkevm-mainnet';
+function getOrderbookConfig(environment) {
+    switch (environment) {
+        case Environment$1.SANDBOX:
+            return {
+                seaportContractAddress: '0x410000346E270aDbC89b2b688177d3AE76348dE9',
+                zoneContractAddress: '0x979C2aCA989A56554Eb63E01e576E3179Cdad5A0',
+                apiEndpoint: 'https://order-book-mr.sandbox.imtbl.com',
+                chainName: TESTNET_CHAIN_NAME,
+                provider: new providers.JsonRpcProvider('https://rpc.testnet.immutable.com'),
+            };
+        // not yet deployed
+        case Environment$1.PRODUCTION:
+            return {
+                seaportContractAddress: '',
+                zoneContractAddress: '',
+                apiEndpoint: 'https://api.immutable.com',
+                chainName: MAINNET_CHAIN_NAME,
+                provider: new providers.JsonRpcProvider('https://rpc.immutable.com'),
+            };
+        default:
+            return null;
+    }
+}
+
+class ERC721 {
+    erc721;
+    constructor(erc721) {
+        this.erc721 = erc721;
+    }
+    async royaltyInfo(tokenId, salePrice) {
+        const [recipient, royaltyRequired] = await this.erc721.royaltyInfo(tokenId, salePrice);
+        return { recipient, amountRequired: royaltyRequired.toString() };
+    }
+}
+
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+const _abi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner_",
+                type: "address",
+            },
+            {
+                internalType: "string",
+                name: "name_",
+                type: "string",
+            },
+            {
+                internalType: "string",
+                name: "symbol_",
+                type: "string",
+            },
+            {
+                internalType: "string",
+                name: "baseURI_",
+                type: "string",
+            },
+            {
+                internalType: "string",
+                name: "contractURI_",
+                type: "string",
+            },
+            {
+                internalType: "address",
+                name: "_receiver",
+                type: "address",
+            },
+            {
+                internalType: "uint96",
+                name: "_feeNumerator",
+                type: "uint96",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "target",
+                type: "address",
+            },
+        ],
+        name: "ApproveTargetNotInAllowlist",
+        type: "error",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "caller",
+                type: "address",
+            },
+        ],
+        name: "CallerNotInAllowlist",
+        type: "error",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "approved",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "Approval",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "approved",
+                type: "bool",
+            },
+        ],
+        name: "ApprovalForAll",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                indexed: true,
+                internalType: "bytes32",
+                name: "previousAdminRole",
+                type: "bytes32",
+            },
+            {
+                indexed: true,
+                internalType: "bytes32",
+                name: "newAdminRole",
+                type: "bytes32",
+            },
+        ],
+        name: "RoleAdminChanged",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+        ],
+        name: "RoleGranted",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+        ],
+        name: "RoleRevoked",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "oldRegistry",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "newRegistry",
+                type: "address",
+            },
+        ],
+        name: "RoyaltytAllowlistRegistryUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "Transfer",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "DEFAULT_ADMIN_ROLE",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "MINTER_ROLE",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "approve",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "baseURI",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "burn",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "contractURI",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getAdmins",
+        outputs: [
+            {
+                internalType: "address[]",
+                name: "",
+                type: "address[]",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "getApproved",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+        ],
+        name: "getRoleAdmin",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                internalType: "uint256",
+                name: "index",
+                type: "uint256",
+            },
+        ],
+        name: "getRoleMember",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+        ],
+        name: "getRoleMemberCount",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "user",
+                type: "address",
+            },
+        ],
+        name: "grantMinterRole",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "grantRole",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "hasRole",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+        ],
+        name: "isApprovedForAll",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        name: "mint",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "name",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "ownerOf",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "renounceRole",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "user",
+                type: "address",
+            },
+        ],
+        name: "revokeMinterRole",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "role",
+                type: "bytes32",
+            },
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "revokeRole",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "royaltyAllowlist",
+        outputs: [
+            {
+                internalType: "contract IRoyaltyAllowlist",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "_tokenId",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "_salePrice",
+                type: "uint256",
+            },
+        ],
+        name: "royaltyInfo",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "safeTransferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes",
+            },
+        ],
+        name: "safeTransferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+            {
+                internalType: "bool",
+                name: "approved",
+                type: "bool",
+            },
+        ],
+        name: "setApprovalForAll",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "string",
+                name: "baseURI_",
+                type: "string",
+            },
+        ],
+        name: "setBaseURI",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "string",
+                name: "_contractURI",
+                type: "string",
+            },
+        ],
+        name: "setContractURI",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "_royaltyAllowlist",
+                type: "address",
+            },
+        ],
+        name: "setRoyaltyAllowlistRegistry",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes4",
+                name: "interfaceId",
+                type: "bytes4",
+            },
+        ],
+        name: "supportsInterface",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "symbol",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "index",
+                type: "uint256",
+            },
+        ],
+        name: "tokenByIndex",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "index",
+                type: "uint256",
+            },
+        ],
+        name: "tokenOfOwnerByIndex",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "tokenURI",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "totalSupply",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "transferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+class ImmutableERC721Base__factory {
+    static abi = _abi;
+    static createInterface() {
+        return new utils.Interface(_abi);
+    }
+    static connect(address, signerOrProvider) {
+        return new Contract$1(address, _abi, signerOrProvider);
+    }
+}
+
+class ERC721Factory {
+    erc721;
+    constructor(contractAddress, provider) {
+        this.erc721 = ImmutableERC721Base__factory.connect(contractAddress, provider);
+    }
+    create() {
+        return new ERC721(this.erc721);
+    }
+}
+
+class SeaportLibFactory {
+    defaultSeaportContractAddress;
+    provider;
+    constructor(defaultSeaportContractAddress, provider) {
+        this.defaultSeaportContractAddress = defaultSeaportContractAddress;
+        this.provider = provider;
+    }
+    create(orderSeaportVersion, orderSeaportAddress) {
+        const seaportVersion = orderSeaportVersion ?? SEAPORT_CONTRACT_VERSION_V1_4;
+        const seaportContractAddress = orderSeaportAddress ?? this.defaultSeaportContractAddress;
+        return new Seaport$1(this.provider, {
+            seaportVersion,
+            balanceAndApprovalChecksOnOrderCreation: true,
+            overrides: {
+                contractAddress: seaportContractAddress,
+            },
+        });
+    }
+}
+
+/**
+ * zkEVM orderbook SDK
+ * @constructor
+ * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
+ */
+class Orderbook {
+    apiClient;
+    seaport;
+    orderbookConfig;
+    constructor(config) {
+        const obConfig = getOrderbookConfig(config.baseConfig.environment);
+        const finalConfig = {
+            ...obConfig,
+            ...config.overrides,
+        };
+        if (!finalConfig) {
+            throw new Error('Orderbook configuration not passed, please specify the environment under config.baseConfig.environment');
+        }
+        this.orderbookConfig = finalConfig;
+        const { apiEndpoint, chainName } = this.orderbookConfig;
+        if (!apiEndpoint) {
+            throw new Error('API endpoint must be provided');
+        }
+        this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
+        const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);
+        this.seaport = new Seaport(seaportLibFactory, this.orderbookConfig.provider, this.orderbookConfig.seaportContractAddress, this.orderbookConfig.zoneContractAddress);
+    }
+    /**
+     * Get an order by ID
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned order result.
+     */
+    getListing(listingId) {
+        return this.apiClient.getListing(listingId);
+    }
+    /**
+     * List orders. This method is used to get a list of orders filtered by conditions specified
+     * in the params object.
+     * @param {ListOrderParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {Orders} The paged orders.
+     */
+    listListings(listOrderParams) {
+        return this.apiClient.listListings(listOrderParams);
+    }
+    /**
+     * Get required transactions and messages for signing prior to creating a listing
+     * through the createListing 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 `createListing` with a signature.
+     */
+    async prepareListing({ makerAddress, sell, buy, orderExpiry, }) {
+        const erc721 = new ERC721Factory(sell.contractAddress, this.orderbookConfig.provider).create();
+        const royaltyInfo = await erc721.royaltyInfo(sell.tokenId, buy.amount);
+        return this.seaport.prepareSeaportOrder(makerAddress, sell, buy, royaltyInfo, 
+        // Default order start to now
+        new Date(), 
+        // Default order expiry to 2 years from now
+        orderExpiry || new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 2));
+    }
+    /**
+     * Create an order
+     * @param {CreateListingParams} createListingParams - create an order with the given params.
+     * @return {ListingResult} The result of the order created in the Immutable services.
+     */
+    createListing(createListingParams) {
+        return this.apiClient.createListing(createListingParams);
+    }
+    /**
+     * 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} listingId - The listingId to fulfil.
+     * @param {string} fulfillerAddress - The address of the account fulfilling the order.
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
+     */
+    async fulfillOrder(listingId, takerAddress) {
+        const orderResult = await this.apiClient.getListing(listingId);
+        if (orderResult.result.status !== OrderStatus.ACTIVE) {
+            throw new Error(`Cannot fulfil order that is not active. Current status: ${orderResult.result.status}`);
+        }
+        return this.seaport.fulfillOrder(orderResult.result, takerAddress);
+    }
+    /**
+     * Get an unsigned cancel order transaction. Orders can only be cancelled by
+     * the account that created them.
+     * @param {string} listingId - The listingId to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the order.
+     * @return {CancelOrderResponse} The unsigned cancel order transaction
+     */
+    async cancelOrder(listingId, accountAddress) {
+        const orderResult = await this.apiClient.getListing(listingId);
+        if (orderResult.result.status !== OrderStatus.ACTIVE
+            && orderResult.result.status !== OrderStatus.INACTIVE
+            && orderResult.result.status !== OrderStatus.PENDING) {
+            throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
+        }
+        if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
+            throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${listingId}`);
+        }
+        const cancelOrderTransaction = await this.seaport.cancelOrder(orderResult.result, accountAddress);
+        return { unsignedCancelOrderTransaction: cancelOrderTransaction };
+    }
+}
+
+/* eslint-disable class-methods-use-this */ 
+
+const $762782b6c862d954$export$db5daa1b5156ccfe = [
+    {
+        constant: true,
+        inputs: [],
+        name: "name",
+        outputs: [
+            {
+                name: "",
+                type: "string"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "decimals",
+        outputs: [
+            {
+                name: "",
+                type: "uint8"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "_owner",
+                type: "address"
+            }
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                name: "balance",
+                type: "uint256"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "symbol",
+        outputs: [
+            {
+                name: "",
+                type: "string"
+            }
+        ],
+        payable: false,
+        type: "function"
+    }
+];
+
+
+var $aa144554f9ef124b$export$1fc8f52ad1810e52;
+(function(ItemType) {
+    ItemType["NATIVE"] = "NATIVE";
+    ItemType["ERC20"] = "ERC20";
+    ItemType["ERC721"] = "ERC721";
+})($aa144554f9ef124b$export$1fc8f52ad1810e52 || ($aa144554f9ef124b$export$1fc8f52ad1810e52 = {}));
+var $aa144554f9ef124b$export$537fa3efd10ed435;
+(function(GasTokenType) {
+    GasTokenType["NATIVE"] = "NATIVE";
+    GasTokenType["ERC20"] = "ERC20";
+})($aa144554f9ef124b$export$537fa3efd10ed435 || ($aa144554f9ef124b$export$537fa3efd10ed435 = {}));
+
+
+/**
+ * Enum representing different chain IDs.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain ID for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain ID for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain ID for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain ID for Ethereum.
+ * @property {number} SEPOLIA - The chain ID for Sepolia.
+ */ var $0472f23319457bfb$export$c06e1e7429de6283;
+(function(ChainId) {
+    ChainId[ChainId["IMTBL_ZKEVM_MAINNET"] = 13371] = "IMTBL_ZKEVM_MAINNET";
+    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13472] = "IMTBL_ZKEVM_TESTNET";
+    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13433] = "IMTBL_ZKEVM_DEVNET";
+    ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
+    ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
+})($0472f23319457bfb$export$c06e1e7429de6283 || ($0472f23319457bfb$export$c06e1e7429de6283 = {}));
+var $0472f23319457bfb$export$b874c6b1dfe85e02;
+(function(ChainName) {
+    ChainName["ETHEREUM"] = "Ethereum";
+    ChainName["SEPOLIA"] = "Sepolia";
+    ChainName["IMTBL_ZKEVM_TESTNET"] = "Immutable zkEVM Test";
+    ChainName["IMTBL_ZKEVM_DEVNET"] = "Immutable zkEVM Dev";
+    ChainName["IMTBL_ZKEVM_MAINNET"] = "Immutable zkEVM";
+})($0472f23319457bfb$export$b874c6b1dfe85e02 || ($0472f23319457bfb$export$b874c6b1dfe85e02 = {}));
+
+
+
+
+
+
+var $de275b98d2b651c3$export$788b1fd17f3dad84;
+(function(GasEstimateType) {
+    GasEstimateType["BRIDGE_TO_L2"] = "BRIDGE_TO_L2";
+    GasEstimateType["SWAP"] = "SWAP";
+})($de275b98d2b651c3$export$788b1fd17f3dad84 || ($de275b98d2b651c3$export$788b1fd17f3dad84 = {}));
+
+
+var $a47e48dd2c04791b$export$1f05a55fe0680cc7;
+(function(NetworkFilterTypes) {
+    NetworkFilterTypes["ALL"] = "all";
 })($a47e48dd2c04791b$export$1f05a55fe0680cc7 || ($a47e48dd2c04791b$export$1f05a55fe0680cc7 = {}));
 
 
@@ -15557,6 +17571,7 @@ var $4f91c5f280efe242$export$a75605c67ea83a5a;
 var $e768639828688ca3$export$2d7a51a18d87e21d;
 (function(WalletProviderName) {
     WalletProviderName["METAMASK"] = "metamask";
+    WalletProviderName["PASSPORT"] = "passport";
 })($e768639828688ca3$export$2d7a51a18d87e21d || ($e768639828688ca3$export$2d7a51a18d87e21d = {}));
 const $e768639828688ca3$export$44dde05038008549 = {
     allowMistmatchedChainId: false,
@@ -15572,10 +17587,6 @@ const $d85ad1457a3f1a83$export$161d4a74df65fc08 = {
     [(Environment$1).SANDBOX]: "https://checkout-api.sandbox.immutable.com",
     [(Environment$1).PRODUCTION]: "https://checkout-api.immutable.com"
 };
-const $d85ad1457a3f1a83$export$7b057be2a3f512cc = {
-    [(Environment$1).SANDBOX]: "https://zkevm-rpc.sandbox.imtbl.com",
-    [(Environment$1).PRODUCTION]: "https://zkevm-rpc.imtbl.com"
-};
 const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
     [
         ($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM,
@@ -15705,6 +17716,8 @@ const $d85ad1457a3f1a83$export$3a9ebede6a150274 = new Map([
     CheckoutErrorType["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
     CheckoutErrorType["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
     CheckoutErrorType["INVALID_GAS_ESTIMATE_TYPE"] = "INVALID_GAS_ESTIMATE_TYPE";
+    CheckoutErrorType["UNSUPPORTED_TOKEN_TYPE_ERROR"] = "UNSUPPORTED_TOKEN_TYPE_ERROR";
+    CheckoutErrorType["GET_ORDER_LISTING_ERROR"] = "GET_ORDER_LISTING_ERROR";
 })($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     message;
@@ -16151,6 +18164,7 @@ async function $570856c68db0bd36$export$9e73e22953cebcfc(tokenBridge, tokenAddre
 
 
 
+
 async function $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config) {
     const rootChainProvider = readOnlyProviders.get(fromChainId);
     const childChainProvider = readOnlyProviders.get(toChainId);
@@ -16179,6 +18193,13 @@ async function $67fc622a2b913d5f$export$7cf6178417769841(chainId, config) {
         overrides: dexConfig?.overrides
     });
 }
+async function $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config) {
+    return new (Orderbook)({
+        baseConfig: {
+            environment: config.environment
+        }
+    });
+}
 
 
 
@@ -16200,7 +18221,7 @@ class $a492ee374ae7b613$export$d902b56530cd5f87 {
     static async makeHttpRequest(url) {
         let response;
         try {
-            response = await (0, $7v2Z6$axios).get(url);
+            response = await (0, axios).get(url);
         } catch (error) {
             throw new Error(`Error fetching from api: ${error.message}`);
         }
@@ -16245,23 +18266,10 @@ class $4013c5c91bb535f6$export$6ad73ea7e1b6f37f extends Error {
         this.message = message;
     }
 }
-const $4013c5c91bb535f6$var$networkMap = (prod, dev, local)=>{
-    let networks;
-    if (dev) networks = ($d85ad1457a3f1a83$export$3a9ebede6a150274);
-    else if (prod) {
-        networks = ($d85ad1457a3f1a83$export$6f24f3cef7d501c4);
-        if (local) {
-            const rpcUrls = networks.get(($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET)?.rpcUrls;
-            rpcUrls?.splice(0, 1, ($d85ad1457a3f1a83$export$7b057be2a3f512cc)[(Environment$1).PRODUCTION]);
-        }
-    } else {
-        networks = ($d85ad1457a3f1a83$export$3e81fc0987227f10);
-        if (local) {
-            const rpcUrls = networks.get(($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET)?.rpcUrls;
-            rpcUrls?.splice(0, 1, ($d85ad1457a3f1a83$export$7b057be2a3f512cc)[(Environment$1).SANDBOX]);
-        }
-    }
-    return networks;
+const $4013c5c91bb535f6$var$networkMap = (prod, dev)=>{
+    if (dev) return $d85ad1457a3f1a83$export$3a9ebede6a150274;
+    if (prod) return $d85ad1457a3f1a83$export$6f24f3cef7d501c4;
+    return $d85ad1457a3f1a83$export$3e81fc0987227f10;
 };
 const $4013c5c91bb535f6$export$9b794d067cdd1af6 = (config)=>{
     // DevMode and Sandbox will both use Sepolia.
@@ -16279,11 +18287,6 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
     // This will be used to get around the lack of
     // Environment.DEVELOPMENT
     isDevelopment = false;
-    // This is a hidden feature that is only available
-    // when building the project from source code.
-    // This will be used to get around the lack of
-    // Environment.LOCAL_DEVELOPMENT
-    isLocal = false;
     isProduction;
     remote;
     environment;
@@ -16293,7 +18296,7 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
         this.environment = config.baseConfig.environment;
         // Developer mode will super set any environment configuration
         this.isProduction = !this.isDevelopment && this.environment === (Environment$1).PRODUCTION;
-        this.networkMap = $4013c5c91bb535f6$var$networkMap(this.isProduction, this.isDevelopment, this.isLocal);
+        this.networkMap = $4013c5c91bb535f6$var$networkMap(this.isProduction, this.isDevelopment);
         this.remote = new ($a492ee374ae7b613$export$d902b56530cd5f87)({
             isDevelopment: this.isDevelopment,
             isProduction: this.isProduction
@@ -16403,6 +18406,84 @@ async function $2e7bf45a7c9a9570$export$942c8de7174809fc(params, readOnlyProvide
 
 
 
+const $c147333b1f360629$export$92589613aaa38e1f = 300000;
+const $c147333b1f360629$export$dea9ce0e9bb2441c = "0x474989C4D25DD41B0B9b1ECb4643B9Fe25f83B19";
+const $c147333b1f360629$export$5baee63457fa7911 = (type, amount, contractAddress)=>{
+    switch(type){
+        case ($aa144554f9ef124b$export$1fc8f52ad1810e52).ERC20:
+        case ($aa144554f9ef124b$export$1fc8f52ad1810e52).ERC721:
+            return {
+                type: type,
+                amount: amount,
+                contractAddress: contractAddress,
+                approvalContractAddress: $c147333b1f360629$export$dea9ce0e9bb2441c
+            };
+        case ($aa144554f9ef124b$export$1fc8f52ad1810e52).NATIVE:
+        default:
+            return {
+                type: ($aa144554f9ef124b$export$1fc8f52ad1810e52).NATIVE,
+                amount: amount
+            };
+    }
+};
+const $c147333b1f360629$export$7f8e2b98eca5a7f0 = async (config, provider, orderId)=>{
+    let order;
+    try {
+        const orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        order = await orderbook.getListing(orderId);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while getting the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ORDER_LISTING_ERROR, {
+            orderId: orderId,
+            message: err.message
+        });
+    }
+    let amount = (BigNumber$2).from("0");
+    let type = ($aa144554f9ef124b$export$1fc8f52ad1810e52).NATIVE;
+    let contractAddress = "";
+    const buyArray = order.result.buy;
+    if (buyArray.length > 0) switch(buyArray[0].item_type){
+        case "NATIVE":
+            type = ($aa144554f9ef124b$export$1fc8f52ad1810e52).NATIVE;
+            break;
+        case "ERC20":
+            type = ($aa144554f9ef124b$export$1fc8f52ad1810e52).ERC20;
+            contractAddress = buyArray[0].contract_address;
+            break;
+        case "ERC721":
+            type = ($aa144554f9ef124b$export$1fc8f52ad1810e52).ERC721;
+            contractAddress = buyArray[0].contract_address;
+            break;
+        default:
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Purchasing token type is unsupported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_TOKEN_TYPE_ERROR, {
+                orderId: orderId
+            });
+    }
+    buyArray.forEach((item)=>{
+        amount = amount.add((BigNumber$2).from(item.start_amount));
+    });
+    const feeArray = order.result.fees;
+    feeArray.forEach((item)=>{
+        amount = amount.add((BigNumber$2).from(item.amount));
+    });
+    const requirements = [
+        $c147333b1f360629$export$5baee63457fa7911(type, amount, contractAddress)
+    ];
+    return {
+        requirements: requirements,
+        gas: {
+            type: ($aa144554f9ef124b$export$537fa3efd10ed435).NATIVE,
+            limit: (BigNumber$2).from($c147333b1f360629$export$92589613aaa38e1f)
+        }
+    };
+};
+
+
+
+
+
+
+
+
 async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
     if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
     if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
@@ -16537,6 +18618,15 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(this.config, web3Provider);
     }
     /**
+   * Determines the requirements for performing a buy.
+   * @param {BuyParams} params - The parameters for the buy.
+  */ async buy(params) {
+        // eslint-disable-next-line no-console
+        console.warn("This endpoint is currently under construction.");
+        const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
+        await $c147333b1f360629$export$7f8e2b98eca5a7f0(this.config, web3Provider, params.orderId);
+    }
+    /**
    * Checks if the given object is a Web3 provider.
    * @param {Web3Provider} web3Provider - The object to check.
    * @returns {boolean} - True if the object is a Web3 provider, false otherwise.