@imtbl/sdk 0.1.7-alpha.1 → 0.1.7

package/dist/orderbook.js

@@ -1,1833 +0,0 @@
-import { ItemType, SEAPORT_CONTRACT_NAME, SEAPORT_CONTRACT_VERSION_V1_4, EIP_712_ORDER_TYPE, OrderType } from '@opensea/seaport-js/lib/constants';
-import FormData from 'form-data';
-import fetch, { Headers } from 'node-fetch';
-import { utils, Contract, BigNumber, constants } from 'ethers';
-import { Seaport as Seaport$1 } from '@opensea/seaport-js';
-
-class BaseHttpRequest {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-}
-
-class ApiError extends Error {
-    url;
-    status;
-    statusText;
-    body;
-    request;
-    constructor(request, response, message) {
-        super(message);
-        this.name = 'ApiError';
-        this.url = response.url;
-        this.status = response.status;
-        this.statusText = response.statusText;
-        this.body = response.body;
-        this.request = request;
-    }
-}
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-class CancelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CancelError';
-    }
-    get isCancelled() {
-        return true;
-    }
-}
-class CancelablePromise {
-    [Symbol.toStringTag];
-    _isResolved;
-    _isRejected;
-    _isCancelled;
-    _cancelHandlers;
-    _promise;
-    _resolve;
-    _reject;
-    constructor(executor) {
-        this._isResolved = false;
-        this._isRejected = false;
-        this._isCancelled = false;
-        this._cancelHandlers = [];
-        this._promise = new Promise((resolve, reject) => {
-            this._resolve = resolve;
-            this._reject = reject;
-            const onResolve = (value) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._isResolved = true;
-                this._resolve?.(value);
-            };
-            const onReject = (reason) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._isRejected = true;
-                this._reject?.(reason);
-            };
-            const onCancel = (cancelHandler) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
-                }
-                this._cancelHandlers.push(cancelHandler);
-            };
-            Object.defineProperty(onCancel, 'isResolved', {
-                get: () => this._isResolved,
-            });
-            Object.defineProperty(onCancel, 'isRejected', {
-                get: () => this._isRejected,
-            });
-            Object.defineProperty(onCancel, 'isCancelled', {
-                get: () => this._isCancelled,
-            });
-            return executor(onResolve, onReject, onCancel);
-        });
-    }
-    then(onFulfilled, onRejected) {
-        return this._promise.then(onFulfilled, onRejected);
-    }
-    catch(onRejected) {
-        return this._promise.catch(onRejected);
-    }
-    finally(onFinally) {
-        return this._promise.finally(onFinally);
-    }
-    cancel() {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
-            return;
-        }
-        this._isCancelled = true;
-        if (this._cancelHandlers.length) {
-            try {
-                for (const cancelHandler of this._cancelHandlers) {
-                    cancelHandler();
-                }
-            }
-            catch (error) {
-                console.warn('Cancellation threw an error', error);
-                return;
-            }
-        }
-        this._cancelHandlers.length = 0;
-        this._reject?.(new CancelError('Request aborted'));
-    }
-    get isCancelled() {
-        return this._isCancelled;
-    }
-}
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-const isDefined = (value) => {
-    return value !== undefined && value !== null;
-};
-const isString = (value) => {
-    return typeof value === 'string';
-};
-const isStringWithValue = (value) => {
-    return isString(value) && value !== '';
-};
-const isBlob = (value) => {
-    return (typeof value === 'object' &&
-        typeof value.type === 'string' &&
-        typeof value.stream === 'function' &&
-        typeof value.arrayBuffer === 'function' &&
-        typeof value.constructor === 'function' &&
-        typeof value.constructor.name === 'string' &&
-        /^(Blob|File)$/.test(value.constructor.name) &&
-        /^(Blob|File)$/.test(value[Symbol.toStringTag]));
-};
-const isFormData = (value) => {
-    return value instanceof FormData;
-};
-const base64 = (str) => {
-    try {
-        return btoa(str);
-    }
-    catch (err) {
-        // @ts-ignore
-        return Buffer.from(str).toString('base64');
-    }
-};
-const getQueryString = (params) => {
-    const qs = [];
-    const append = (key, value) => {
-        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
-    };
-    const process = (key, value) => {
-        if (isDefined(value)) {
-            if (Array.isArray(value)) {
-                value.forEach(v => {
-                    process(key, v);
-                });
-            }
-            else if (typeof value === 'object') {
-                Object.entries(value).forEach(([k, v]) => {
-                    process(`${key}[${k}]`, v);
-                });
-            }
-            else {
-                append(key, value);
-            }
-        }
-    };
-    Object.entries(params).forEach(([key, value]) => {
-        process(key, value);
-    });
-    if (qs.length > 0) {
-        return `?${qs.join('&')}`;
-    }
-    return '';
-};
-const getUrl = (config, options) => {
-    const encoder = config.ENCODE_PATH || encodeURI;
-    const path = options.url
-        .replace('{api-version}', config.VERSION)
-        .replace(/{(.*?)}/g, (substring, group) => {
-        if (options.path?.hasOwnProperty(group)) {
-            return encoder(String(options.path[group]));
-        }
-        return substring;
-    });
-    const url = `${config.BASE}${path}`;
-    if (options.query) {
-        return `${url}${getQueryString(options.query)}`;
-    }
-    return url;
-};
-const getFormData = (options) => {
-    if (options.formData) {
-        const formData = new FormData();
-        const process = (key, value) => {
-            if (isString(value) || isBlob(value)) {
-                formData.append(key, value);
-            }
-            else {
-                formData.append(key, JSON.stringify(value));
-            }
-        };
-        Object.entries(options.formData)
-            .filter(([_, value]) => isDefined(value))
-            .forEach(([key, value]) => {
-            if (Array.isArray(value)) {
-                value.forEach(v => process(key, v));
-            }
-            else {
-                process(key, value);
-            }
-        });
-        return formData;
-    }
-    return undefined;
-};
-const resolve = async (options, resolver) => {
-    if (typeof resolver === 'function') {
-        return resolver(options);
-    }
-    return resolver;
-};
-const getHeaders = async (config, options) => {
-    const token = await resolve(options, config.TOKEN);
-    const username = await resolve(options, config.USERNAME);
-    const password = await resolve(options, config.PASSWORD);
-    const additionalHeaders = await resolve(options, config.HEADERS);
-    const headers = Object.entries({
-        Accept: 'application/json',
-        ...additionalHeaders,
-        ...options.headers,
-    })
-        .filter(([_, value]) => isDefined(value))
-        .reduce((headers, [key, value]) => ({
-        ...headers,
-        [key]: String(value),
-    }), {});
-    if (isStringWithValue(token)) {
-        headers['Authorization'] = `Bearer ${token}`;
-    }
-    if (isStringWithValue(username) && isStringWithValue(password)) {
-        const credentials = base64(`${username}:${password}`);
-        headers['Authorization'] = `Basic ${credentials}`;
-    }
-    if (options.body) {
-        if (options.mediaType) {
-            headers['Content-Type'] = options.mediaType;
-        }
-        else if (isBlob(options.body)) {
-            headers['Content-Type'] = 'application/octet-stream';
-        }
-        else if (isString(options.body)) {
-            headers['Content-Type'] = 'text/plain';
-        }
-        else if (!isFormData(options.body)) {
-            headers['Content-Type'] = 'application/json';
-        }
-    }
-    return new Headers(headers);
-};
-const getRequestBody = (options) => {
-    if (options.body) {
-        if (options.mediaType?.includes('/json')) {
-            return JSON.stringify(options.body);
-        }
-        else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
-            return options.body;
-        }
-        else {
-            return JSON.stringify(options.body);
-        }
-    }
-    return undefined;
-};
-const sendRequest = async (options, url, body, formData, headers, onCancel) => {
-    const controller = new AbortController();
-    const request = {
-        headers,
-        method: options.method,
-        body: body ?? formData,
-        signal: controller.signal,
-    };
-    onCancel(() => controller.abort());
-    return await fetch(url, request);
-};
-const getResponseHeader = (response, responseHeader) => {
-    if (responseHeader) {
-        const content = response.headers.get(responseHeader);
-        if (isString(content)) {
-            return content;
-        }
-    }
-    return undefined;
-};
-const getResponseBody = async (response) => {
-    if (response.status !== 204) {
-        try {
-            const contentType = response.headers.get('Content-Type');
-            if (contentType) {
-                const isJSON = contentType.toLowerCase().startsWith('application/json');
-                if (isJSON) {
-                    return await response.json();
-                }
-                else {
-                    return await response.text();
-                }
-            }
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-    return undefined;
-};
-const catchErrorCodes = (options, result) => {
-    const errors = {
-        400: 'Bad Request',
-        401: 'Unauthorized',
-        403: 'Forbidden',
-        404: 'Not Found',
-        500: 'Internal Server Error',
-        502: 'Bad Gateway',
-        503: 'Service Unavailable',
-        ...options.errors,
-    };
-    const error = errors[result.status];
-    if (error) {
-        throw new ApiError(options, result, error);
-    }
-    if (!result.ok) {
-        throw new ApiError(options, result, 'Generic Error');
-    }
-};
-/**
- * Request method
- * @param config The OpenAPI configuration object
- * @param options The request options from the service
- * @returns CancelablePromise<T>
- * @throws ApiError
- */
-const request = (config, options) => {
-    return new CancelablePromise(async (resolve, reject, onCancel) => {
-        try {
-            const url = getUrl(config, options);
-            const formData = getFormData(options);
-            const body = getRequestBody(options);
-            const headers = await getHeaders(config, options);
-            if (!onCancel.isCancelled) {
-                const response = await sendRequest(options, url, body, formData, headers, onCancel);
-                const responseBody = await getResponseBody(response);
-                const responseHeader = getResponseHeader(response, options.responseHeader);
-                const result = {
-                    url,
-                    ok: response.ok,
-                    status: response.status,
-                    statusText: response.statusText,
-                    body: responseHeader ?? responseBody,
-                };
-                catchErrorCodes(options, result);
-                resolve(result.body);
-            }
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-};
-
-class NodeHttpRequest extends BaseHttpRequest {
-    constructor(config) {
-        super(config);
-    }
-    /**
-     * Request method
-     * @param options The request options from the service
-     * @returns CancelablePromise<T>
-     * @throws ApiError
-     */
-    request(options) {
-        return request(this.config, options);
-    }
-}
-
-class OrdersService {
-    httpRequest;
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * List all orders
-     * List all orders
-     * @returns Orders OK response.
-     * @throws ApiError
-     */
-    listOrders({ chainId, pageSize = 100, sortBy, sortDirection, pageCursor, }) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/v1/chains/{chain_id}/orders',
-            path: {
-                'chain_id': chainId,
-            },
-            query: {
-                'page_size': pageSize,
-                'sort_by': sortBy,
-                'sort_direction': sortDirection,
-                'page_cursor': pageCursor,
-            },
-            errors: {
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
-            },
-        });
-    }
-    /**
-     * Create an order
-     * Create an order
-     * @returns Order Created response.
-     * @throws ApiError
-     */
-    createOrder({ chainId, requestBody, }) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/v1/chains/{chain_id}/orders',
-            path: {
-                'chain_id': chainId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `bad_request: Bad Request`,
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
-            },
-        });
-    }
-    /**
-     * Get a single order by ID
-     * Get a single order by ID
-     * @returns Order OK response.
-     * @throws ApiError
-     */
-    getOrder({ chainId, orderId, }) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/v1/chains/{chain_id}/orders/{order_id}',
-            path: {
-                'chain_id': chainId,
-                'order_id': orderId,
-            },
-            errors: {
-                404: `not_found: Resource not found`,
-                500: `internal_error: Internal server error`,
-            },
-        });
-    }
-}
-
-class OrderBookClient {
-    orders;
-    request;
-    constructor(config, HttpRequest = NodeHttpRequest) {
-        this.request = new HttpRequest({
-            BASE: config?.BASE ?? 'https://order-book-mr.dev.imtbl.com',
-            VERSION: config?.VERSION ?? '1.0.0',
-            WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
-            CREDENTIALS: config?.CREDENTIALS ?? 'include',
-            TOKEN: config?.TOKEN,
-            USERNAME: config?.USERNAME,
-            PASSWORD: config?.PASSWORD,
-            HEADERS: config?.HEADERS,
-            ENCODE_PATH: config?.ENCODE_PATH,
-        });
-        this.orders = new OrdersService(this.request);
-    }
-}
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var BuyItem;
-(function (BuyItem) {
-    (function (item_type) {
-        item_type["ERC20"] = "ERC20";
-        item_type["IMX"] = "IMX";
-    })(BuyItem.item_type || (BuyItem.item_type = {}));
-})(BuyItem || (BuyItem = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var CreateOrderProtocolData;
-(function (CreateOrderProtocolData) {
-    (function (order_type) {
-        order_type["FULL_OPEN"] = "FULL_OPEN";
-    })(CreateOrderProtocolData.order_type || (CreateOrderProtocolData.order_type = {}));
-})(CreateOrderProtocolData || (CreateOrderProtocolData = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var Fee;
-(function (Fee) {
-    (function (fee_type) {
-        fee_type["ROYALTY"] = "ROYALTY";
-    })(Fee.fee_type || (Fee.fee_type = {}));
-})(Fee || (Fee = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var Order;
-(function (Order) {
-    (function (status) {
-        status["PENDING"] = "PENDING";
-        status["ACTIVE"] = "ACTIVE";
-        status["CANCELLED"] = "CANCELLED";
-        status["INACTIVE"] = "INACTIVE";
-        status["REJECTED"] = "REJECTED";
-        status["FILLED"] = "FILLED";
-        status["EXPIRED"] = "EXPIRED";
-    })(Order.status || (Order.status = {}));
-})(Order || (Order = {}));
-
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var SellItem;
-(function (SellItem) {
-    (function (item_type) {
-        item_type["ERC721"] = "ERC721";
-    })(SellItem.item_type || (SellItem.item_type = {}));
-})(SellItem || (SellItem = {}));
-
-class ImmutableApiClient {
-    orderbookService;
-    chainId;
-    constructor(orderbookService, chainId) {
-        this.orderbookService = orderbookService;
-        this.chainId = chainId;
-    }
-    async getOrder(orderId) {
-        return this.orderbookService.getOrder({ chainId: this.chainId, orderId });
-    }
-    async createOrder({ orderHash, orderComponents, offerer, orderSignature, }) {
-        if (orderComponents.offer.length !== 1) {
-            throw new Error('Only one item can be listed at a time');
-        }
-        if (Number(orderComponents.offer[0].itemType) !== ItemType.ERC721) {
-            throw new Error('Only ERC721 tokens can be listed');
-        }
-        const considerationItemTypeTheSame = new Set([...orderComponents.consideration.map((c) => c.itemType)]).size === 1;
-        if (!considerationItemTypeTheSame) {
-            throw new Error('All consideration items must be of the same type');
-        }
-        return this.orderbookService.createOrder({
-            chainId: this.chainId,
-            requestBody: {
-                order_hash: orderHash,
-                account_address: offerer,
-                buy: [
-                    {
-                        item_type: Number(orderComponents.consideration[0].itemType) === ItemType.NATIVE
-                            ? BuyItem.item_type.IMX
-                            : BuyItem.item_type.ERC20,
-                        start_amount: orderComponents.consideration[0].startAmount,
-                    }
-                ],
-                buy_fees: orderComponents.consideration.length > 1
-                    ? [
-                        {
-                            amount: orderComponents.consideration[1].startAmount,
-                            recipient: orderComponents.consideration[1].recipient,
-                            fee_type: Fee.fee_type.ROYALTY,
-                        },
-                    ]
-                    : [],
-                end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
-                protocol_data: {
-                    order_type: CreateOrderProtocolData.order_type.FULL_OPEN,
-                    zone_address: orderComponents.zone,
-                },
-                salt: orderComponents.salt,
-                sell: [{
-                        contract_address: orderComponents.offer[0].token,
-                        token_id: orderComponents.offer[0].identifierOrCriteria,
-                        item_type: SellItem.item_type.ERC721,
-                    }],
-                signature: orderSignature,
-                start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
-            },
-        });
-    }
-}
-
-class ImmutableApiClientFactory {
-    chainId;
-    orderbookClient;
-    constructor(apiEndpoint, chainId) {
-        this.chainId = chainId;
-        this.orderbookClient = new OrderBookClient({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            BASE: apiEndpoint,
-        });
-    }
-    create() {
-        return new ImmutableApiClient(this.orderbookClient.orders, this.chainId);
-    }
-}
-
-class ERC721 {
-    erc721;
-    constructor(erc721) {
-        this.erc721 = erc721;
-    }
-    async royaltyInfo(tokenId, salePrice) {
-        const [recipient, royaltyRequired] = await this.erc721.royaltyInfo(tokenId, salePrice);
-        return { recipient, amountRequired: royaltyRequired.toString() };
-    }
-}
-
-/* Autogenerated file. Do not edit manually. */
-/* tslint:disable */
-/* eslint-disable */
-const _abi = [
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner_",
-                type: "address",
-            },
-            {
-                internalType: "string",
-                name: "name_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "symbol_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "baseURI_",
-                type: "string",
-            },
-            {
-                internalType: "string",
-                name: "contractURI_",
-                type: "string",
-            },
-            {
-                internalType: "address",
-                name: "_receiver",
-                type: "address",
-            },
-            {
-                internalType: "uint96",
-                name: "_feeNumerator",
-                type: "uint96",
-            },
-        ],
-        stateMutability: "nonpayable",
-        type: "constructor",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "target",
-                type: "address",
-            },
-        ],
-        name: "ApproveTargetNotInAllowlist",
-        type: "error",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "caller",
-                type: "address",
-            },
-        ],
-        name: "CallerNotInAllowlist",
-        type: "error",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "approved",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "Approval",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-            {
-                indexed: false,
-                internalType: "bool",
-                name: "approved",
-                type: "bool",
-            },
-        ],
-        name: "ApprovalForAll",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "previousAdminRole",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "newAdminRole",
-                type: "bytes32",
-            },
-        ],
-        name: "RoleAdminChanged",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "sender",
-                type: "address",
-            },
-        ],
-        name: "RoleGranted",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "sender",
-                type: "address",
-            },
-        ],
-        name: "RoleRevoked",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: false,
-                internalType: "address",
-                name: "oldRegistry",
-                type: "address",
-            },
-            {
-                indexed: false,
-                internalType: "address",
-                name: "newRegistry",
-                type: "address",
-            },
-        ],
-        name: "RoyaltytAllowlistRegistryUpdated",
-        type: "event",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "Transfer",
-        type: "event",
-    },
-    {
-        inputs: [],
-        name: "DEFAULT_ADMIN_ROLE",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "MINTER_ROLE",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "approve",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-        ],
-        name: "balanceOf",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "baseURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "burn",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "contractURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getAdmins",
-        outputs: [
-            {
-                internalType: "address[]",
-                name: "",
-                type: "address[]",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "getApproved",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-        ],
-        name: "getRoleAdmin",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "getRoleMember",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-        ],
-        name: "getRoleMemberCount",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "user",
-                type: "address",
-            },
-        ],
-        name: "grantMinterRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "grantRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "hasRole",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-        ],
-        name: "isApprovedForAll",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "amount",
-                type: "uint256",
-            },
-        ],
-        name: "mint",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "name",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "ownerOf",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "renounceRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "user",
-                type: "address",
-            },
-        ],
-        name: "revokeMinterRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes32",
-                name: "role",
-                type: "bytes32",
-            },
-            {
-                internalType: "address",
-                name: "account",
-                type: "address",
-            },
-        ],
-        name: "revokeRole",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "royaltyAllowlist",
-        outputs: [
-            {
-                internalType: "contract IRoyaltyAllowlist",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "_tokenId",
-                type: "uint256",
-            },
-            {
-                internalType: "uint256",
-                name: "_salePrice",
-                type: "uint256",
-            },
-        ],
-        name: "royaltyInfo",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "safeTransferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-            {
-                internalType: "bytes",
-                name: "data",
-                type: "bytes",
-            },
-        ],
-        name: "safeTransferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "operator",
-                type: "address",
-            },
-            {
-                internalType: "bool",
-                name: "approved",
-                type: "bool",
-            },
-        ],
-        name: "setApprovalForAll",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "string",
-                name: "baseURI_",
-                type: "string",
-            },
-        ],
-        name: "setBaseURI",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "string",
-                name: "_contractURI",
-                type: "string",
-            },
-        ],
-        name: "setContractURI",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "_royaltyAllowlist",
-                type: "address",
-            },
-        ],
-        name: "setRoyaltyAllowlistRegistry",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes4",
-                name: "interfaceId",
-                type: "bytes4",
-            },
-        ],
-        name: "supportsInterface",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "symbol",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "tokenByIndex",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "owner",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "index",
-                type: "uint256",
-            },
-        ],
-        name: "tokenOfOwnerByIndex",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "tokenURI",
-        outputs: [
-            {
-                internalType: "string",
-                name: "",
-                type: "string",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalSupply",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "from",
-                type: "address",
-            },
-            {
-                internalType: "address",
-                name: "to",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "tokenId",
-                type: "uint256",
-            },
-        ],
-        name: "transferFrom",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-];
-class ImmutableERC721Base__factory {
-    static abi = _abi;
-    static createInterface() {
-        return new utils.Interface(_abi);
-    }
-    static connect(address, signerOrProvider) {
-        return new Contract(address, _abi, signerOrProvider);
-    }
-}
-
-class ERC721Factory {
-    erc721;
-    constructor(contractAddress, provider) {
-        this.erc721 = ImmutableERC721Base__factory.connect(contractAddress, provider);
-    }
-    create() {
-        return new ERC721(this.erc721);
-    }
-}
-
-function getOrderComponentsFromMessage(orderMessage) {
-    const data = JSON.parse(orderMessage);
-    const orderComponents = data.message;
-    orderComponents.salt = BigNumber.from(orderComponents.salt).toHexString();
-    return orderComponents;
-}
-
-// Add 20% more gas than estimate to prevent out of gas errors
-// This can always be overwritten by the user signing the transaction
-async function prepareTransaction(transactionMethods) {
-    const transaction = await transactionMethods.buildTransaction();
-    transaction.gasLimit = await transactionMethods.estimateGas();
-    transaction.gasLimit = transaction.gasLimit
-        .add(transaction.gasLimit.div(5));
-    return transaction;
-}
-
-function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
-    const considerationItems = order.buy.map((buyItem) => ({
-        startAmount: buyItem.start_amount,
-        endAmount: buyItem.start_amount,
-        itemType: buyItem.item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
-        recipient: order.account_address,
-        token: buyItem.contract_address || constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    const fees = order.buy_fees.map((fee) => ({
-        startAmount: fee.amount,
-        endAmount: fee.amount,
-        itemType: order.buy[0].item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
-        recipient: fee.recipient,
-        token: order.buy[0].contract_address || constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    return {
-        conduitKey: constants.HashZero,
-        consideration: [...considerationItems, ...fees],
-        offer: order.sell.map((sellItem) => ({
-            startAmount: '1',
-            endAmount: '1',
-            itemType: ItemType.ERC721,
-            token: sellItem.contract_address,
-            identifierOrCriteria: sellItem.token_id,
-        })),
-        counter,
-        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
-        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
-        salt: order.salt,
-        offerer: order.account_address,
-        zone: zoneAddress,
-        totalOriginalConsiderationItems: 2,
-        orderType: OrderType.FULL_RESTRICTED,
-        zoneHash: constants.HashZero,
-    };
-}
-
-class Seaport {
-    seaport;
-    provider;
-    seaportContractAddress;
-    zoneContractAddress;
-    constructor(seaport, provider, seaportContractAddress, zoneContractAddress) {
-        this.seaport = seaport;
-        this.provider = provider;
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-    }
-    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const createAction = actions
-            .find((action) => action.type === 'create');
-        if (!createAction) {
-            throw new Error('No create order action found');
-        }
-        const orderMessageToSign = await createAction.getMessageToSign();
-        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
-            orderComponents,
-            orderHash: await this.seaport.getOrderHash(orderComponents),
-        };
-    }
-    async fulfilOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const { actions } = await this.seaport.fulfillOrders({
-            accountAddress: account,
-            fulfillOrderDetails: [{
-                    order: {
-                        parameters: orderComponents,
-                        signature: order.signature,
-                    },
-                }],
-        });
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const fulfillmentAction = actions
-            .find((action) => action.type === 'exchange');
-        if (!fulfillmentAction) {
-            throw new Error('No exchange action found');
-        }
-        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            unsignedFulfillmentTransaction: fulfillmentTransaction,
-        };
-    }
-    async cancelOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const cancellationTransaction = await this.seaport.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction);
-    }
-    async mapImmutableOrderToSeaportOrderComponents(order) {
-        const counterForOfferer = await this.seaport.getCounter(order.account_address);
-        return mapImmutableOrderToSeaportOrderComponents(order, counterForOfferer.toString(), this.zoneContractAddress);
-    }
-    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        return this.seaport.createOrder({
-            allowPartialFills: false,
-            offer: [
-                {
-                    itemType: ItemType.ERC721,
-                    token: listingItem.contractAddress,
-                    identifier: listingItem.tokenId,
-                },
-            ],
-            consideration: [
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: considerationItem.amount,
-                    recipient: offerer,
-                },
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: royaltyInfo.amountRequired,
-                    recipient: royaltyInfo.recipient,
-                },
-            ],
-            startTime: (orderStart.getTime() / 1000).toFixed(0),
-            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
-            zone: this.zoneContractAddress,
-            restrictedByZone: true,
-        }, offerer);
-    }
-    async getTypedDataFromOrderComponents(orderComponents) {
-        const { chainId } = await this.provider.getNetwork();
-        const domainData = {
-            name: SEAPORT_CONTRACT_NAME,
-            version: SEAPORT_CONTRACT_VERSION_V1_4,
-            chainId,
-            verifyingContract: this.seaportContractAddress,
-        };
-        return {
-            domain: domainData,
-            types: EIP_712_ORDER_TYPE,
-            value: orderComponents,
-        };
-    }
-}
-
-class SeaportFactory {
-    seaportContractAddress;
-    zoneContractAddress;
-    provider;
-    seaport;
-    constructor(seaportContractAddress, zoneContractAddress, provider) {
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-        this.provider = provider;
-        this.seaport = new Seaport$1(provider, {
-            seaportVersion: '1.4',
-            balanceAndApprovalChecksOnOrderCreation: true,
-            overrides: {
-                contractAddress: seaportContractAddress,
-            },
-        });
-    }
-    create() {
-        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
-    }
-}
-
-/**
- * zkEVM orderbook SDK
- * @constructor
- * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
- */
-class Orderbook {
-    config;
-    apiClient;
-    seaport;
-    constructor(config) {
-        this.config = config;
-        // TODO: Move endpoint lookup to a map based on env. Just using override to get dev started
-        const apiEndpoint = config.overrides?.apiEndpoint;
-        if (!apiEndpoint) {
-            throw new Error('API endpoint must be provided as an override');
-        }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainId = config.overrides?.chainId;
-        if (!chainId) {
-            throw new Error('ChainID must be provided as an override');
-        }
-        this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainId).create();
-        this.seaport = new SeaportFactory(this.config.seaportContractAddress, this.config.zoneContractAddress, this.config.provider).create();
-    }
-    /**
-     * Get an order by ID
-     * @param {string} orderId - The orderId to find.
-     * @return {Order} The returned order.
-     */
-    getOrder(orderId) {
-        return this.apiClient.getOrder(orderId);
-    }
-    /**
-     * Get required transactions and messages for signing prior to creating a listing
-     * through the createOrder method
-     * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
-     * @return {PrepareListingResponse} PrepareListingResponse includes
-     * the unsigned approval transaction, the typed order message for signing and
-     * the order components that can be submitted to `createOrder` with a signature.
-     */
-    async prepareListing({ offerer, listingItem, considerationItem, orderExpiry, }) {
-        const erc721 = new ERC721Factory(listingItem.contractAddress, this.config.provider).create();
-        const royaltyInfo = await erc721.royaltyInfo(listingItem.tokenId, considerationItem.amount);
-        return this.seaport.prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, 
-        // Default order start to now
-        new Date(), 
-        // Default order expiry to 2 years from now
-        orderExpiry || new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 2));
-    }
-    /**
-     * Create an order
-     * @param {CreateOrderParams} createOrderParams - create an order with the given params.
-     * @return {Order} The order created in the Immutable services.
-     */
-    createOrder(createOrderParams) {
-        return this.apiClient.createOrder(createOrderParams);
-    }
-    /**
-     * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
-     * transaction exists it must be signed and submitted to the chain before the fulfilment
-     * transaction can be submitted or it will be reverted.
-     * @param {string} orderId - The orderId to fulfil.
-     * @param {string} fulfillerAddress - The address of the account fulfilling the order.
-     * @return {FulfilOrderResponse} Approval and fulfilment transactions.
-     */
-    async fulfillOrder(orderId, fulfillerAddress) {
-        const order = await this.apiClient.getOrder(orderId);
-        if (order.status !== Order.status.ACTIVE) {
-            throw new Error(`Cannot fulfil order that is not active. Current status: ${order.status}`);
-        }
-        return this.seaport.fulfilOrder(order, fulfillerAddress);
-    }
-    /**
-     * Get an unsigned cancel order transaction. Orders can only be cancelled by
-     * the account that created them.
-     * @param {string} orderId - The orderId to cancel.
-     * @param {string} accountAddress - The address of the account cancelling the order.
-     * @return {CancelOrderResponse} The unsigned cancel order transaction
-     */
-    async cancelOrder(orderId, accountAddress) {
-        const order = await this.apiClient.getOrder(orderId);
-        if (order.status !== Order.status.ACTIVE
-            && order.status !== Order.status.INACTIVE
-            && order.status !== Order.status.PENDING) {
-            throw new Error(`Cannot cancel order with status ${order.status}`);
-        }
-        if (order.account_address !== accountAddress.toLowerCase()) {
-            throw new Error(`Only account ${order.account_address} can cancel order ${orderId}`);
-        }
-        const cancelOrderTransaction = await this.seaport.cancelOrder(order, accountAddress);
-        return { unsignedCancelOrderTransaction: cancelOrderTransaction };
-    }
-}
-
-const module = 'orderbook';
-
-export { Orderbook, module };