@maxion-platform/ronin-market-sdk 1.0.0

package/dist/cjs/queries/order/types.js

@@ -0,0 +1,43 @@
+'use strict';
+
+exports.OrderStatus = void 0;
+(function (OrderStatus) {
+    OrderStatus["CANCELLED"] = "CANCELLED";
+    OrderStatus["EXPIRED"] = "EXPIRED";
+    OrderStatus["INVALID_ITEM_AMOUNT"] = "INVALID_ITEM_AMOUNT";
+    OrderStatus["INVALID_ITEM_AMOUNT_AND_UNAPPROVED_ITEM"] = "INVALID_ITEM_AMOUNT_AND_UNAPPROVED_ITEM";
+    OrderStatus["INVALID_WRON_APPROVE_AMOUNT"] = "INVALID_WRON_APPROVE_AMOUNT";
+    OrderStatus["INVALID_WRON_INSUFFICIENT"] = "INVALID_WRON_INSUFFICIENT";
+    OrderStatus["INVALID_WRON_INSUFFICIENT_AND_APPROVE_AMOUNT"] = "INVALID_WRON_INSUFFICIENT_AND_APPROVE_AMOUNT";
+    OrderStatus["LOCKED_ITEM"] = "LOCKED_ITEM";
+    OrderStatus["MATCHED"] = "MATCHED";
+    OrderStatus["OFFERER_CANCEL"] = "OFFERER_CANCEL";
+    OrderStatus["OPEN"] = "OPEN";
+    OrderStatus["OPENED"] = "OPENED";
+    OrderStatus["PARTIALLY_CANCELLED"] = "PARTIALLY_CANCELLED";
+    OrderStatus["PARTIALLY_EXPIRED"] = "PARTIALLY_EXPIRED";
+    OrderStatus["PARTIALLY_MATCHED"] = "PARTIALLY_MATCHED";
+    OrderStatus["PASIVELY_CANCELLED"] = "PASIVELY_CANCELLED";
+    OrderStatus["REOPEN"] = "REOPEN";
+    OrderStatus["REVALID_WRON_SUFFICIENT"] = "REVALID_WRON_SUFFICIENT";
+    OrderStatus["TRANSFERRED_ITEM"] = "TRANSFERRED_ITEM";
+    OrderStatus["UNAPPROVED_ITEM"] = "UNAPPROVED_ITEM";
+})(exports.OrderStatus || (exports.OrderStatus = {}));
+exports.OrderType = void 0;
+(function (OrderType) {
+    OrderType["Offer"] = "Offer";
+    OrderType["Sell"] = "Sell";
+})(exports.OrderType || (exports.OrderType = {}));
+exports.AuctionType = void 0;
+(function (AuctionType) {
+    AuctionType["All"] = "All";
+    AuctionType["NotForSale"] = "NotForSale";
+    AuctionType["Sale"] = "Sale";
+})(exports.AuctionType || (exports.AuctionType = {}));
+exports.ListingSortBy = void 0;
+(function (ListingSortBy) {
+    ListingSortBy["ExpiredAtAsc"] = "ExpiredAtAsc";
+    ListingSortBy["ExpiredAtDesc"] = "ExpiredAtDesc";
+    ListingSortBy["PriceAsc"] = "PriceAsc";
+    ListingSortBy["PriceDesc"] = "PriceDesc";
+})(exports.ListingSortBy || (exports.ListingSortBy = {}));

package/dist/cjs/queries/token/index.js

@@ -0,0 +1,226 @@
+'use strict';
+
+var index = require('../graphql/index.js');
+require('../graphql/queries/collection.js');
+var types$2 = require('../collection/types.js');
+var metadata = require('../graphql/mutations/metadata.js');
+var token = require('../graphql/queries/token.js');
+var types$1 = require('../order/types.js');
+var types = require('./types.js');
+
+// Erc721
+const getErc721Tokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = { showMinPrice: false, ...otherParams };
+    return index.graphQLRequest({ query: token.GET_ERC721_TOKENS, variables, chainId }).then(response => {
+        const erc721Tokens = response?.erc721Tokens || {};
+        const { total, results } = erc721Tokens;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+const getErc721Token = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = { showMinPrice: false, ...otherParams };
+    return index.graphQLRequest({ query: token.GET_ERC721_TOKEN, variables, chainId }).then(response => response?.erc721Token);
+};
+const getErc721TokenTransferHistory = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC721_TRANSFER_HISTORY,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        const transferHistory = response?.erc721Token?.transferHistory || {};
+        const { total, results } = transferHistory;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+// Erc1155
+const getErc1155Tokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = { showMinPrice: false, ...otherParams };
+    return index.graphQLRequest({ query: token.GET_ERC1155_TOKENS, variables, chainId }).then(response => {
+        const erc1155Tokens = response?.erc1155Tokens || {};
+        const { total, results } = erc1155Tokens;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+const getErc1155Token = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = { showMinPrice: false, ...otherParams };
+    return index.graphQLRequest({ query: token.GET_ERC1155_TOKEN, variables, chainId }).then(response => response?.erc1155Token);
+};
+const getErc1155TokenTransferHistory = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC1155_TRANSFER_HISTORY,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        const transferHistory = response?.erc1155Token?.transferHistory || {};
+        const { total, results } = transferHistory;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+const getErc1155Balance = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC1155_BALANCE,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => response?.erc1155Token?.balance);
+};
+const getAllTokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = {
+        auctionType: types$1.AuctionType.All,
+        sort: types$1.ListingSortBy.PriceAsc,
+        tokenAddresses: [],
+        ...otherParams,
+    };
+    return index.graphQLRequest({
+        query: token.GET_ALL_TOKENS,
+        variables,
+        chainId,
+    }).then(response => {
+        const results = response?.tokens || {};
+        const { total, data } = results;
+        const tokens = (data || []).map((tokenInfo) => {
+            const { erc721TokenAddress, erc721TokenId, erc721CollectionMetadata, erc721Image, erc721CdnImage, erc721Video, erc721Name, erc721Order, erc721IsLocked, } = tokenInfo;
+            const { erc1155TokenAddress, erc1155TokenId, erc1155CollectionMetadata, erc1155Image, erc1155CdnImage, erc1155Video, erc1155Name, erc1155Orders, erc1155Balance, } = tokenInfo;
+            const isErc721 = !!erc721TokenId;
+            return {
+                ercType: isErc721 ? types$2.Erc.Erc721 : types$2.Erc.Erc1155,
+                data: {
+                    tokenAddress: erc721TokenAddress || erc1155TokenAddress,
+                    tokenId: erc721TokenId || erc1155TokenId,
+                    owner: params.owner,
+                    name: erc721Name || erc1155Name,
+                    image: erc721Image || erc1155Image,
+                    cdnImage: erc721CdnImage || erc1155CdnImage,
+                    video: erc721Video || erc1155Video,
+                    isLocked: isErc721 ? erc721IsLocked : false,
+                    collectionMetadata: erc721CollectionMetadata || erc1155CollectionMetadata,
+                    balance: isErc721 ? null : erc1155Balance,
+                    orders: isErc721 ? erc721Order : erc1155Orders,
+                },
+            };
+        });
+        return {
+            total: total || 0,
+            tokens,
+        };
+    });
+};
+const refreshMetadata = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: metadata.REFRESH_METADATA,
+        variables: { ...otherParams },
+        chainId,
+    });
+};
+const getMyErc1155TokensList = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_MY_ERC1155_TOKENS_LIST,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        const erc1155Tokens = response?.erc1155Tokens || {};
+        const { total, results } = erc1155Tokens;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+const getTokenData = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_TOKEN_DATA,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        return response?.tokenData || null;
+    });
+};
+const getErc1155TokenWithOrders = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC1155_TOKEN_WITH_ORDERS,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        return response?.erc1155Token || null;
+    });
+};
+const getErc1155TokensList = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC1155_TOKENS_LIST,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        const erc1155Tokens = response?.erc1155Tokens || {};
+        const { total, results } = erc1155Tokens;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+const getErc1155TokensListWithTraits = (params) => {
+    const { chainId, ...otherParams } = params;
+    return index.graphQLRequest({
+        query: token.GET_ERC1155_TOKENS_LIST_WITH_TRAITS,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        const erc1155Tokens = response?.erc1155Tokens || {};
+        const { total, results } = erc1155Tokens;
+        return {
+            total: total || 0,
+            results: results || [],
+        };
+    });
+};
+
+Object.defineProperty(exports, 'AttributeType', {
+  enumerable: true,
+  get: function () { return types.AttributeType; }
+});
+Object.defineProperty(exports, 'Erc1155SortBy', {
+  enumerable: true,
+  get: function () { return types.Erc1155SortBy; }
+});
+Object.defineProperty(exports, 'SortBy', {
+  enumerable: true,
+  get: function () { return types.SortBy; }
+});
+exports.getAllTokens = getAllTokens;
+exports.getErc1155Balance = getErc1155Balance;
+exports.getErc1155Token = getErc1155Token;
+exports.getErc1155TokenTransferHistory = getErc1155TokenTransferHistory;
+exports.getErc1155TokenWithOrders = getErc1155TokenWithOrders;
+exports.getErc1155Tokens = getErc1155Tokens;
+exports.getErc1155TokensList = getErc1155TokensList;
+exports.getErc1155TokensListWithTraits = getErc1155TokensListWithTraits;
+exports.getErc721Token = getErc721Token;
+exports.getErc721TokenTransferHistory = getErc721TokenTransferHistory;
+exports.getErc721Tokens = getErc721Tokens;
+exports.getMyErc1155TokensList = getMyErc1155TokensList;
+exports.getTokenData = getTokenData;
+exports.refreshMetadata = refreshMetadata;

package/dist/cjs/queries/token/types.js

@@ -0,0 +1,24 @@
+'use strict';
+
+exports.SortBy = void 0;
+(function (SortBy) {
+    SortBy["IdAsc"] = "IdAsc";
+    SortBy["IdDesc"] = "IdDesc";
+    SortBy["Latest"] = "Latest";
+    SortBy["PriceAsc"] = "PriceAsc";
+    SortBy["PriceDesc"] = "PriceDesc";
+})(exports.SortBy || (exports.SortBy = {}));
+exports.Erc1155SortBy = void 0;
+(function (Erc1155SortBy) {
+    Erc1155SortBy["Latest"] = "Latest";
+    Erc1155SortBy["PriceAsc"] = "PriceAsc";
+    Erc1155SortBy["PriceDesc"] = "PriceDesc";
+})(exports.Erc1155SortBy || (exports.Erc1155SortBy = {}));
+exports.AttributeType = void 0;
+(function (AttributeType) {
+    AttributeType["Date"] = "date";
+    AttributeType["NumberRanking"] = "number_ranking";
+    AttributeType["String"] = "string";
+    AttributeType["Number"] = "number";
+    AttributeType["Price"] = "price";
+})(exports.AttributeType || (exports.AttributeType = {}));

package/dist/cjs/services/balance/checkIsInsufficientBalance.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var ethers = require('ethers');
+var fetchBalances = require('./fetchBalances.js');
+
+const checkIsInsufficientBalance = async (chainId, tokenAddress, account, amount) => {
+    const currentBalance = await fetchBalances.fetchPaymentTokenBalance(chainId, tokenAddress, account);
+    return ethers.BigNumber.from(amount).gt(currentBalance);
+};
+const checkIsInsufficientOfferBalance = async (chainId, account, amount) => {
+    const wRonBalance = await fetchBalances.fetchOfferBalance(chainId, account);
+    return ethers.BigNumber.from(amount).gt(wRonBalance);
+};
+
+exports.checkIsInsufficientBalance = checkIsInsufficientBalance;
+exports.checkIsInsufficientOfferBalance = checkIsInsufficientOfferBalance;

package/dist/cjs/services/balance/fetchBalances.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var index = require('../../contracts/index.js');
+require('../../configs/index.js');
+var data = require('../tokens/data.js');
+var getPaymentTokens = require('../tokens/getPaymentTokens.js');
+require('lodash');
+require('ethers');
+
+const fetchOfferBalance = (chainId, account) => {
+    const wRonContract = index.createWRonContract(chainId);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    return wRonContract.connect(readProvider).balanceOf(account);
+};
+const fetchPaymentTokenBalance = (chainId, tokenAddress, account) => {
+    const paymentTokens = getPaymentTokens.getPaymentTokens(chainId);
+    const erc20Contract = index.createErc20Contract(tokenAddress);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const isRon = paymentTokens[data.Token.RON].address.toLowerCase() === tokenAddress.toLowerCase();
+    if (isRon) {
+        return readProvider.getBalance(account);
+    }
+    return erc20Contract.connect(readProvider).balanceOf(account);
+};
+
+exports.fetchOfferBalance = fetchOfferBalance;
+exports.fetchPaymentTokenBalance = fetchPaymentTokenBalance;

package/dist/cjs/services/order/bulkSettleOrders.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var index = require('../../contracts/index.js');
+var types = require('../../queries/collection/types.js');
+
+const bulkSettleOrders = (params) => {
+    const { chainId, wallet, bulkBuyData, paymentToken, totalSettlePrice, tokenType, requiredAllSuccess = false, options, } = params;
+    if (tokenType === types.Erc.Erc721) {
+        return bulkSettleErc721Orders(chainId, wallet, bulkBuyData, paymentToken, totalSettlePrice, requiredAllSuccess, options);
+    }
+    return bulkSettleErc1155Orders(chainId, wallet, bulkBuyData, paymentToken, totalSettlePrice, requiredAllSuccess, options);
+};
+const bulkSettleErc721Orders = (chainId, wallet, ordersData, paymentToken, totalSettlePrice, requiredAllSuccess, options) => {
+    const { provider } = wallet;
+    const marketGatewayMultisendContract = index.createMarketGatewayMultiSendContract(chainId, provider);
+    return marketGatewayMultisendContract.bulkSettleErc721Orders(chainId, wallet, ordersData, paymentToken, totalSettlePrice, requiredAllSuccess, options);
+};
+const bulkSettleErc1155Orders = (chainId, wallet, ordersData, paymentToken, totalSettlePrice, requiredAllSuccess, options) => {
+    const { provider } = wallet;
+    const marketGatewayMultisendContract = index.createMarketGatewayMultiSendContract(chainId, provider);
+    return marketGatewayMultisendContract.bulkSettleErc1155Orders(chainId, wallet, ordersData, paymentToken, totalSettlePrice, requiredAllSuccess, options);
+};
+
+exports.bulkSettleErc1155Orders = bulkSettleErc1155Orders;
+exports.bulkSettleErc721Orders = bulkSettleErc721Orders;
+exports.bulkSettleOrders = bulkSettleOrders;

package/dist/cjs/services/order/checkIsOrderValid.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var index = require('../../contracts/index.js');
+require('ethers');
+var Erc1155OrderExchange__factory = require('../../contracts/abis/types/v5/factories/Erc1155OrderExchange__factory.js');
+var MavisExchange__factory = require('../../contracts/abis/types/v5/factories/MavisExchange__factory.js');
+require('graphql-request');
+require('../../types/index.js');
+require('../../queries/graphql/queries/collection.js');
+require('../../queries/collection/types.js');
+require('../../queries/graphql/queries/exchange-rate.js');
+require('../../queries/graphql/queries/offer.js');
+require('../../queries/offer/types.js');
+require('../../queries/graphql/mutations/order.js');
+require('../../queries/graphql/queries/order.js');
+require('../../queries/token/types.js');
+var types = require('../../queries/order/types.js');
+require('../../queries/graphql/mutations/metadata.js');
+require('../../queries/graphql/queries/token.js');
+var generateOrderData = require('./generateOrderData.js');
+var factory = require('../../contracts/market-gateway/factory.js');
+
+const checkIsErc721OrderValid = async (chainId, order) => {
+    const { hash } = order;
+    const formattedHash = hash.includes('0x') ? hash : `0x${hash}`;
+    const erc721Order = generateOrderData.generateErc721Order(order);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId);
+    const encodedOrder = marketGatewayContract.encodeOrder(erc721Order);
+    const params = MavisExchange__factory.MavisExchange__factory.createInterface().encodeFunctionData('orderValid', [
+        formattedHash,
+        encodedOrder,
+    ]);
+    const encodedResponse = await readProvider.call({
+        to: marketGatewayContract.address,
+        data: marketGatewayContract.interface.encodeFunctionData('interactWith', [
+            marketGatewayContract._orderExchangeInterface,
+            params,
+        ]),
+    });
+    const result = MavisExchange__factory.MavisExchange__factory.createInterface().decodeFunctionResult('orderValid', encodedResponse);
+    return result?.[0] === true;
+};
+const checkIsErc1155OrderValid = async (chainId, order) => {
+    const { hash, orderStatus } = order;
+    const formattedHash = hash.includes('0x') ? hash : `0x${hash}`;
+    const invalidStatusList = [types.OrderStatus.INVALID_ITEM_AMOUNT];
+    const isInvalidOrder = invalidStatusList.includes(orderStatus);
+    if (isInvalidOrder) {
+        return false;
+    }
+    const erc1155Order = generateOrderData.generateErc1155Order(order);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const erc1155marketGatewayContract = factory.createErc1155MarketGatewayContract(chainId);
+    const encodedOrder = erc1155marketGatewayContract.encodeErc1155Order(erc1155Order);
+    const params = Erc1155OrderExchange__factory.Erc1155OrderExchange__factory.createInterface().encodeFunctionData('orderValid', [
+        formattedHash,
+        encodedOrder,
+    ]);
+    const encodedResponse = await readProvider.call({
+        to: erc1155marketGatewayContract.address,
+        data: erc1155marketGatewayContract.interface.encodeFunctionData('interactWith', [
+            erc1155marketGatewayContract._orderExchangeInterface,
+            params,
+        ]),
+    });
+    const result = Erc1155OrderExchange__factory.Erc1155OrderExchange__factory.createInterface().decodeFunctionResult('orderValid', encodedResponse);
+    return result?.[0] === true;
+};
+
+exports.checkIsErc1155OrderValid = checkIsErc1155OrderValid;
+exports.checkIsErc721OrderValid = checkIsErc721OrderValid;

package/dist/cjs/services/order/generateOrderData.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var mapData = require('../../utils/mapData.js');
+require('lodash');
+require('../../configs/index.js');
+
+const generateErc721Order = (order) => {
+    const { expiredAt, basePrice, kind, startedAt, assets, paymentToken, maker, expectedState, nonce, marketFeePercentage, } = order;
+    const result = {
+        maker: maker,
+        kind: mapData.getOrderKind(kind),
+        assets: assets.map(asset => {
+            const { address, erc, quantity, id } = asset;
+            return {
+                addr: address,
+                erc: mapData.getErcAssetItem(erc),
+                quantity: Number(quantity),
+                id: id,
+            };
+        }),
+        expiredAt: expiredAt,
+        basePrice: basePrice,
+        paymentToken: paymentToken,
+        startedAt: startedAt,
+        endedAt: 0,
+        endedPrice: '0',
+        expectedState: `${expectedState}`,
+        nonce: nonce,
+        marketFeePercentage: marketFeePercentage,
+    };
+    return result;
+};
+const generateErc1155Order = (order) => {
+    const { expiredAt, basePrice, kind, startedAt, assets, paymentToken, maker, expectedState, nonce } = order;
+    const parsedAssets = assets.map(asset => {
+        return {
+            erc: mapData.getErcAssetItem(asset.erc),
+            addr: asset.address,
+            id: asset.id,
+            quantity: asset.quantity,
+        };
+    });
+    const result = {
+        maker: maker,
+        kind: mapData.getOrderKind(kind),
+        asset: parsedAssets[0],
+        expiredAt: expiredAt,
+        unitPrice: basePrice,
+        paymentToken: paymentToken,
+        startedAt: startedAt,
+        endedAt: 0,
+        endedUnitPrice: '0',
+        expectedState: `${expectedState}`,
+        nonce: nonce,
+    };
+    return result;
+};
+const generateInputOrder = (data) => {
+    const { price, duration, orderType, expectedState, nonce, assets, paymentToken } = data;
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const inputOrder = {
+        nonce,
+        assets: assets.map(asset => {
+            const { addr, erc, quantity, id } = asset;
+            return {
+                erc: mapData.getErcType(erc),
+                address: addr,
+                id: id,
+                quantity: quantity.toString(),
+            };
+        }),
+        startedAt,
+        expiredAt,
+        expectedState,
+        paymentToken,
+        kind: orderType,
+        basePrice: price.toString(),
+    };
+    return inputOrder;
+};
+
+exports.generateErc1155Order = generateErc1155Order;
+exports.generateErc721Order = generateErc721Order;
+exports.generateInputOrder = generateInputOrder;

package/dist/cjs/services/order/getNonce.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('../../contracts/index.js');
+var factory = require('../../contracts/market-gateway/factory.js');
+
+const getNonce = async (chainId, address) => {
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId);
+    const nonce = await marketGatewayContract.connect(readProvider).makerNonce(address);
+    return Number(nonce);
+};
+
+exports.getNonce = getNonce;

package/dist/cjs/services/order/getOrderSignature.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var constants = require('../../common/constants.js');
+var index = require('../../configs/index.js');
+
+const getErc721OrderSignature = (chainId, signer, order) => {
+    const config = index.getConfig(chainId);
+    const { marketGatewayDomain } = config;
+    return signer._signTypedData(marketGatewayDomain, constants.OrderAbiTypes, order);
+};
+const getErc1155OrderSignature = (chainId, signer, order) => {
+    const config = index.getConfig(chainId);
+    const { marketGatewayDomain } = config;
+    return signer._signTypedData(marketGatewayDomain, constants.Erc1155OrderAbiTypes, order);
+};
+
+exports.getErc1155OrderSignature = getErc1155OrderSignature;
+exports.getErc721OrderSignature = getErc721OrderSignature;

package/dist/cjs/services/order/getOrderState.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var index = require('../../contracts/index.js');
+require('ethers');
+var Erc1155OrderExchange__factory = require('../../contracts/abis/types/v5/factories/Erc1155OrderExchange__factory.js');
+var MavisExchange__factory = require('../../contracts/abis/types/v5/factories/MavisExchange__factory.js');
+var factory = require('../../contracts/market-gateway/factory.js');
+
+const getErc721OrderState = async (chainId, orderAssetItem) => {
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const params = MavisExchange__factory.MavisExchange__factory.createInterface().encodeFunctionData('getState', [orderAssetItem]);
+    const encodedResponse = await readProvider.call({
+        to: marketGatewayContract.address,
+        data: marketGatewayContract.interface.encodeFunctionData('interactWith', [
+            marketGatewayContract._orderExchangeInterface,
+            params,
+        ]),
+    });
+    const result = MavisExchange__factory.MavisExchange__factory.createInterface().decodeFunctionResult('getState', encodedResponse);
+    return result?.[0]?.toString();
+};
+const getErc1155OrderState = async (chainId, orderAssetItem) => {
+    const erc1155MarketGatewayContract = factory.createErc1155MarketGatewayContract(chainId);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const params = Erc1155OrderExchange__factory.Erc1155OrderExchange__factory.createInterface().encodeFunctionData('getState', [orderAssetItem]);
+    const encodedResponse = await readProvider.call({
+        to: erc1155MarketGatewayContract.address,
+        data: erc1155MarketGatewayContract.interface.encodeFunctionData('interactWith', [
+            erc1155MarketGatewayContract._orderExchangeInterface,
+            params,
+        ]),
+    });
+    const result = Erc1155OrderExchange__factory.Erc1155OrderExchange__factory.createInterface().decodeFunctionResult('getState', encodedResponse);
+    return result?.[0]?.toString();
+};
+
+exports.getErc1155OrderState = getErc1155OrderState;
+exports.getErc721OrderState = getErc721OrderState;

package/dist/cjs/services/order/getOrdersByCriteria.js

@@ -0,0 +1,38 @@
+'use strict';
+
+require('graphql-request');
+require('../../types/index.js');
+require('../../queries/graphql/mutations/order.js');
+require('../../queries/graphql/queries/order.js');
+var types$1 = require('../../queries/token/types.js');
+var types = require('../../queries/order/types.js');
+var index = require('../../queries/token/index.js');
+
+const getOrdersByCriteria = async (params) => {
+    const { chainId, tokenAddress, maxPrice, criteria, rangeCriteria, from = 0, size = 50 } = params;
+    if (!criteria && !rangeCriteria) {
+        throw new Error('Criteria or rangeCriteria is required');
+    }
+    if (size > 50) {
+        throw new Error('Size must be less than 50');
+    }
+    const searchParams = {
+        chainId,
+        tokenAddress,
+        from,
+        size,
+        auctionType: types.AuctionType.Sale,
+        criteria,
+        sort: types$1.SortBy.PriceAsc,
+        rangeCriteria,
+    };
+    const { results } = await index.getErc1155TokensList(searchParams);
+    const orders = results
+        .flatMap(result => result.orders || [])
+        .filter(order => {
+        return !maxPrice || BigInt(order.currentPrice) <= maxPrice;
+    });
+    return orders;
+};
+
+exports.getOrdersByCriteria = getOrdersByCriteria;

package/dist/cjs/services/order/getOrdersByQuantity.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const getOrdersByQuantity = (orders, quantity) => {
+    let total = 0;
+    const ordersByQuantity = [];
+    for (const order of orders) {
+        const { orderQuantity } = order;
+        const availableQuantity = Number(orderQuantity?.availableQuantity || 0);
+        if (availableQuantity === 0) {
+            continue;
+        }
+        const newTotal = total + availableQuantity;
+        const newQuantity = Math.min(availableQuantity, quantity - total);
+        total = newTotal;
+        ordersByQuantity.push({ quantity: newQuantity, order });
+        if (newTotal >= quantity) {
+            break;
+        }
+    }
+    return ordersByQuantity;
+};
+
+exports.getOrdersByQuantity = getOrdersByQuantity;