@maxion-platform/ronin-market-sdk 1.0.0

package/dist/mjs/queries/offer/types.js

@@ -0,0 +1,9 @@
+var OfferSortBy;
+(function (OfferSortBy) {
+    OfferSortBy["Earliest"] = "Earliest";
+    OfferSortBy["ExpiredAtAsc"] = "ExpiredAtAsc";
+    OfferSortBy["ExpiredAtDesc"] = "ExpiredAtDesc";
+    OfferSortBy["Latest"] = "Latest";
+    OfferSortBy["PriceAsc"] = "PriceAsc";
+    OfferSortBy["PriceDesc"] = "PriceDesc";
+})(OfferSortBy || (OfferSortBy = {}));export{OfferSortBy};

package/dist/mjs/queries/order/index.js

@@ -0,0 +1,59 @@
+import {graphQLRequest}from'../graphql/index.js';import {CREATE_ORDER}from'../graphql/mutations/order.js';import {GET_ERC721_ORDER,GET_ERC1155_ORDERS,GET_ORDER_BY_HASH,GET_ACTIVE_ORDERS_OF_TOKENS,GET_ORDERS_BY_ADDRESS}from'../graphql/queries/order.js';import {Erc1155SortBy}from'../token/types.js';import {ListingSortBy}from'./types.js';export{AuctionType,OrderStatus,OrderType}from'./types.js';const getErc721Order = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: GET_ERC721_ORDER,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => response?.erc721Token?.order);
+};
+const getErc1155Orders = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: GET_ERC1155_ORDERS,
+        variables: { showInvalid: true, sort: Erc1155SortBy.PriceAsc, ...otherParams },
+        chainId,
+    }).then(response => response?.erc1155Token?.orders);
+};
+const getOrderByHash = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: GET_ORDER_BY_HASH,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => response?.order);
+};
+const getOrdersByAddress = (params) => {
+    const { chainId, account, accessToken, ...otherParams } = params;
+    const variables = {
+        sort: ListingSortBy.ExpiredAtAsc,
+        collectibleFilters: {
+            tokenAddresses: [],
+        },
+        roninAddress: account,
+        ...otherParams,
+    };
+    return graphQLRequest({
+        query: GET_ORDERS_BY_ADDRESS,
+        variables,
+        chainId,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    }).then(response => response?.myListingOrders);
+};
+const requestCreateOrder = async (params) => {
+    const { chainId, account, ...otherParams } = params;
+    return graphQLRequest({
+        query: CREATE_ORDER,
+        variables: { maker: account, ...otherParams },
+        chainId,
+    }).then(response => response?.createOrder);
+};
+const getActiveOrdersOfTokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: GET_ACTIVE_ORDERS_OF_TOKENS,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => response?.activeOrdersOfTokens);
+};export{ListingSortBy,getActiveOrdersOfTokens,getErc1155Orders,getErc721Order,getOrderByHash,getOrdersByAddress,requestCreateOrder};

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

@@ -0,0 +1,41 @@
+var OrderStatus;
+(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";
+})(OrderStatus || (OrderStatus = {}));
+var OrderType;
+(function (OrderType) {
+    OrderType["Offer"] = "Offer";
+    OrderType["Sell"] = "Sell";
+})(OrderType || (OrderType = {}));
+var AuctionType;
+(function (AuctionType) {
+    AuctionType["All"] = "All";
+    AuctionType["NotForSale"] = "NotForSale";
+    AuctionType["Sale"] = "Sale";
+})(AuctionType || (AuctionType = {}));
+var ListingSortBy;
+(function (ListingSortBy) {
+    ListingSortBy["ExpiredAtAsc"] = "ExpiredAtAsc";
+    ListingSortBy["ExpiredAtDesc"] = "ExpiredAtDesc";
+    ListingSortBy["PriceAsc"] = "PriceAsc";
+    ListingSortBy["PriceDesc"] = "PriceDesc";
+})(ListingSortBy || (ListingSortBy = {}));export{AuctionType,ListingSortBy,OrderStatus,OrderType};

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

@@ -0,0 +1,189 @@
+import {graphQLRequest}from'../graphql/index.js';import'../graphql/queries/collection.js';import {Erc}from'../collection/types.js';import {REFRESH_METADATA}from'../graphql/mutations/metadata.js';import {GET_ERC721_TRANSFER_HISTORY,GET_ERC1155_TRANSFER_HISTORY,GET_ERC1155_BALANCE,GET_MY_ERC1155_TOKENS_LIST,GET_TOKEN_DATA,GET_ERC1155_TOKEN_WITH_ORDERS,GET_ERC1155_TOKENS_LIST,GET_ERC1155_TOKENS_LIST_WITH_TRAITS,GET_ERC721_TOKENS,GET_ERC721_TOKEN,GET_ERC1155_TOKENS,GET_ERC1155_TOKEN,GET_ALL_TOKENS}from'../graphql/queries/token.js';import {AuctionType,ListingSortBy}from'../order/types.js';export{AttributeType,Erc1155SortBy,SortBy}from'./types.js';// Erc721
+const getErc721Tokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = { showMinPrice: false, ...otherParams };
+    return graphQLRequest({ query: 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 graphQLRequest({ query: GET_ERC721_TOKEN, variables, chainId }).then(response => response?.erc721Token);
+};
+const getErc721TokenTransferHistory = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: 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 graphQLRequest({ query: 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 graphQLRequest({ query: GET_ERC1155_TOKEN, variables, chainId }).then(response => response?.erc1155Token);
+};
+const getErc1155TokenTransferHistory = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: 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 graphQLRequest({
+        query: GET_ERC1155_BALANCE,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => response?.erc1155Token?.balance);
+};
+const getAllTokens = (params) => {
+    const { chainId, ...otherParams } = params;
+    const variables = {
+        auctionType: AuctionType.All,
+        sort: ListingSortBy.PriceAsc,
+        tokenAddresses: [],
+        ...otherParams,
+    };
+    return graphQLRequest({
+        query: 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 ? Erc.Erc721 : 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 graphQLRequest({
+        query: REFRESH_METADATA,
+        variables: { ...otherParams },
+        chainId,
+    });
+};
+const getMyErc1155TokensList = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: 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 graphQLRequest({
+        query: GET_TOKEN_DATA,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        return response?.tokenData || null;
+    });
+};
+const getErc1155TokenWithOrders = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: GET_ERC1155_TOKEN_WITH_ORDERS,
+        variables: { ...otherParams },
+        chainId,
+    }).then(response => {
+        return response?.erc1155Token || null;
+    });
+};
+const getErc1155TokensList = (params) => {
+    const { chainId, ...otherParams } = params;
+    return graphQLRequest({
+        query: 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 graphQLRequest({
+        query: 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 || [],
+        };
+    });
+};export{getAllTokens,getErc1155Balance,getErc1155Token,getErc1155TokenTransferHistory,getErc1155TokenWithOrders,getErc1155Tokens,getErc1155TokensList,getErc1155TokensListWithTraits,getErc721Token,getErc721TokenTransferHistory,getErc721Tokens,getMyErc1155TokensList,getTokenData,refreshMetadata};

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

@@ -0,0 +1,22 @@
+var SortBy;
+(function (SortBy) {
+    SortBy["IdAsc"] = "IdAsc";
+    SortBy["IdDesc"] = "IdDesc";
+    SortBy["Latest"] = "Latest";
+    SortBy["PriceAsc"] = "PriceAsc";
+    SortBy["PriceDesc"] = "PriceDesc";
+})(SortBy || (SortBy = {}));
+var Erc1155SortBy;
+(function (Erc1155SortBy) {
+    Erc1155SortBy["Latest"] = "Latest";
+    Erc1155SortBy["PriceAsc"] = "PriceAsc";
+    Erc1155SortBy["PriceDesc"] = "PriceDesc";
+})(Erc1155SortBy || (Erc1155SortBy = {}));
+var AttributeType;
+(function (AttributeType) {
+    AttributeType["Date"] = "date";
+    AttributeType["NumberRanking"] = "number_ranking";
+    AttributeType["String"] = "string";
+    AttributeType["Number"] = "number";
+    AttributeType["Price"] = "price";
+})(AttributeType || (AttributeType = {}));export{AttributeType,Erc1155SortBy,SortBy};

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

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

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

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

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

@@ -0,0 +1,17 @@
+import {createMarketGatewayMultiSendContract}from'../../contracts/index.js';import {Erc}from'../../queries/collection/types.js';const bulkSettleOrders = (params) => {
+    const { chainId, wallet, bulkBuyData, paymentToken, totalSettlePrice, tokenType, requiredAllSuccess = false, options, } = params;
+    if (tokenType === 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 = 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 = createMarketGatewayMultiSendContract(chainId, provider);
+    return marketGatewayMultisendContract.bulkSettleErc1155Orders(chainId, wallet, ordersData, paymentToken, totalSettlePrice, requiredAllSuccess, options);
+};export{bulkSettleErc1155Orders,bulkSettleErc721Orders,bulkSettleOrders};

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

@@ -0,0 +1,47 @@
+import {createReadOnlyProvider}from'../../contracts/index.js';import'ethers';import {Erc1155OrderExchange__factory}from'../../contracts/abis/types/v5/factories/Erc1155OrderExchange__factory.js';import {MavisExchange__factory}from'../../contracts/abis/types/v5/factories/MavisExchange__factory.js';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/collection.js';import'../../queries/collection/types.js';import'../../queries/graphql/queries/exchange-rate.js';import'../../queries/graphql/queries/offer.js';import'../../queries/offer/types.js';import'../../queries/graphql/mutations/order.js';import'../../queries/graphql/queries/order.js';import'../../queries/token/types.js';import {OrderStatus}from'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import {generateErc721Order,generateErc1155Order}from'./generateOrderData.js';import {createMarketGatewayContract,createErc1155MarketGatewayContract}from'../../contracts/market-gateway/factory.js';const checkIsErc721OrderValid = async (chainId, order) => {
+    const { hash } = order;
+    const formattedHash = hash.includes('0x') ? hash : `0x${hash}`;
+    const erc721Order = generateErc721Order(order);
+    const readProvider = createReadOnlyProvider(chainId);
+    const marketGatewayContract = createMarketGatewayContract(chainId);
+    const encodedOrder = marketGatewayContract.encodeOrder(erc721Order);
+    const params = 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.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 = [OrderStatus.INVALID_ITEM_AMOUNT];
+    const isInvalidOrder = invalidStatusList.includes(orderStatus);
+    if (isInvalidOrder) {
+        return false;
+    }
+    const erc1155Order = generateErc1155Order(order);
+    const readProvider = createReadOnlyProvider(chainId);
+    const erc1155marketGatewayContract = createErc1155MarketGatewayContract(chainId);
+    const encodedOrder = erc1155marketGatewayContract.encodeErc1155Order(erc1155Order);
+    const params = 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.createInterface().decodeFunctionResult('orderValid', encodedResponse);
+    return result?.[0] === true;
+};export{checkIsErc1155OrderValid,checkIsErc721OrderValid};

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

@@ -0,0 +1,76 @@
+import {getOrderKind,getErcAssetItem,getErcType}from'../../utils/mapData.js';import'lodash';import'../../configs/index.js';const generateErc721Order = (order) => {
+    const { expiredAt, basePrice, kind, startedAt, assets, paymentToken, maker, expectedState, nonce, marketFeePercentage, } = order;
+    const result = {
+        maker: maker,
+        kind: getOrderKind(kind),
+        assets: assets.map(asset => {
+            const { address, erc, quantity, id } = asset;
+            return {
+                addr: address,
+                erc: 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: getErcAssetItem(asset.erc),
+            addr: asset.address,
+            id: asset.id,
+            quantity: asset.quantity,
+        };
+    });
+    const result = {
+        maker: maker,
+        kind: 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: getErcType(erc),
+                address: addr,
+                id: id,
+                quantity: quantity.toString(),
+            };
+        }),
+        startedAt,
+        expiredAt,
+        expectedState,
+        paymentToken,
+        kind: orderType,
+        basePrice: price.toString(),
+    };
+    return inputOrder;
+};export{generateErc1155Order,generateErc721Order,generateInputOrder};

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

@@ -0,0 +1,6 @@
+import {createReadOnlyProvider}from'../../contracts/index.js';import {createMarketGatewayContract}from'../../contracts/market-gateway/factory.js';const getNonce = async (chainId, address) => {
+    const readProvider = createReadOnlyProvider(chainId);
+    const marketGatewayContract = createMarketGatewayContract(chainId);
+    const nonce = await marketGatewayContract.connect(readProvider).makerNonce(address);
+    return Number(nonce);
+};export{getNonce};

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

@@ -0,0 +1,10 @@
+import {OrderAbiTypes,Erc1155OrderAbiTypes}from'../../common/constants.js';import {getConfig}from'../../configs/index.js';const getErc721OrderSignature = (chainId, signer, order) => {
+    const config = getConfig(chainId);
+    const { marketGatewayDomain } = config;
+    return signer._signTypedData(marketGatewayDomain, OrderAbiTypes, order);
+};
+const getErc1155OrderSignature = (chainId, signer, order) => {
+    const config = getConfig(chainId);
+    const { marketGatewayDomain } = config;
+    return signer._signTypedData(marketGatewayDomain, Erc1155OrderAbiTypes, order);
+};export{getErc1155OrderSignature,getErc721OrderSignature};

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

@@ -0,0 +1,28 @@
+import {createReadOnlyProvider}from'../../contracts/index.js';import'ethers';import {Erc1155OrderExchange__factory}from'../../contracts/abis/types/v5/factories/Erc1155OrderExchange__factory.js';import {MavisExchange__factory}from'../../contracts/abis/types/v5/factories/MavisExchange__factory.js';import {createMarketGatewayContract,createErc1155MarketGatewayContract}from'../../contracts/market-gateway/factory.js';const getErc721OrderState = async (chainId, orderAssetItem) => {
+    const marketGatewayContract = createMarketGatewayContract(chainId);
+    const readProvider = createReadOnlyProvider(chainId);
+    const params = 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.createInterface().decodeFunctionResult('getState', encodedResponse);
+    return result?.[0]?.toString();
+};
+const getErc1155OrderState = async (chainId, orderAssetItem) => {
+    const erc1155MarketGatewayContract = createErc1155MarketGatewayContract(chainId);
+    const readProvider = createReadOnlyProvider(chainId);
+    const params = 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.createInterface().decodeFunctionResult('getState', encodedResponse);
+    return result?.[0]?.toString();
+};export{getErc1155OrderState,getErc721OrderState};

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

@@ -0,0 +1,26 @@
+import'graphql-request';import'../../types/index.js';import'../../queries/graphql/mutations/order.js';import'../../queries/graphql/queries/order.js';import {SortBy}from'../../queries/token/types.js';import {AuctionType}from'../../queries/order/types.js';import {getErc1155TokensList}from'../../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: AuctionType.Sale,
+        criteria,
+        sort: SortBy.PriceAsc,
+        rangeCriteria,
+    };
+    const { results } = await getErc1155TokensList(searchParams);
+    const orders = results
+        .flatMap(result => result.orders || [])
+        .filter(order => {
+        return !maxPrice || BigInt(order.currentPrice) <= maxPrice;
+    });
+    return orders;
+};export{getOrdersByCriteria};

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

@@ -0,0 +1,19 @@
+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;
+};export{getOrdersByQuantity};

package/dist/mjs/services/order/getOrdersTotalPrice.js

@@ -0,0 +1,36 @@
+import {BigNumber}from'ethers';import {isEmpty}from'lodash';import {createKatanaContract}from'../../contracts/index.js';import {getSwapConfig}from'../tokens/configs.js';import {paymentTokens}from'../tokens/data.js';const getOrdersTotalPrice = async (params) => {
+    const { data, chainId, wallet, token } = params;
+    const { provider } = wallet;
+    const { address } = token || paymentTokens?.[chainId].RON;
+    const katanaContract = createKatanaContract(chainId, provider);
+    const ordersNeedToSwap = data.filter(orderData => orderData.order.paymentToken !== address);
+    const ordersDontNeedToSwap = data.filter(orderData => orderData.order.paymentToken === address);
+    const totalPriceOfEachOrder = {};
+    let totalPrice = ordersDontNeedToSwap.reduce((total, { quantity, order }) => {
+        const { currentPrice, hash } = order;
+        const orderTotalPrice = BigNumber.from(currentPrice).mul(quantity);
+        totalPriceOfEachOrder[hash] = orderTotalPrice.toString();
+        return total.add(orderTotalPrice);
+    }, BigNumber.from(0));
+    const ordersNeedToSwapAmounts = ordersNeedToSwap.map(({ quantity, order }) => {
+        const { paymentToken, currentPrice } = order;
+        const swapConfig = getSwapConfig(chainId, paymentToken);
+        const path = swapConfig[address].path;
+        const orderTotalPrice = BigNumber.from(currentPrice).mul(quantity);
+        return { amount: orderTotalPrice.toString(), path };
+    });
+    if (!isEmpty(ordersNeedToSwap)) {
+        const swappedValues = await katanaContract.getAmountsInMultiCall(ordersNeedToSwapAmounts, chainId);
+        const totalSwappedValues = ordersNeedToSwap.reduce((total, { order }, currentIndex) => {
+            const { hash } = order;
+            const price = swappedValues[currentIndex];
+            totalPriceOfEachOrder[hash] = price.toString();
+            return total.add(price);
+        }, BigNumber.from(0));
+        totalPrice = totalPrice.add(totalSwappedValues);
+    }
+    return {
+        totalPrice: totalPrice.toString(),
+        totalPriceOfEachOrder,
+    };
+};export{getOrdersTotalPrice};

package/dist/mjs/services/order/getSwapTokenData.js

@@ -0,0 +1,25 @@
+import {formatUnits}from'ethers/lib/utils';import {createReadOnlyProvider,createKatanaContract}from'../../contracts/index.js';import'../../configs/index.js';import'../tokens/data.js';import {getPaymentToken}from'../tokens/getPaymentTokens.js';import {getSwapConfig}from'../tokens/configs.js';import'lodash';import'ethers';const getLiquidityProviderFeePercent = (chainId, inputTokenAddress, outputTokenAddress) => {
+    const swapConfig = getSwapConfig(chainId, outputTokenAddress)[inputTokenAddress];
+    return swapConfig?.lpFeePercent;
+};
+const getPriceImpactPercent = async (chainId, inputTokenAddress, outputTokenAddress, fiatValueIn, fiatValueOut) => {
+    const liquidityProviderPercent = getLiquidityProviderFeePercent(chainId, inputTokenAddress, outputTokenAddress);
+    return (1 - fiatValueIn / fiatValueOut) * 100 - liquidityProviderPercent;
+};
+const getLiquidityProviderFee = (chainId, inputTokenAddress, outputTokenAddress, amountIn) => {
+    const inputTokenData = getPaymentToken(chainId, inputTokenAddress);
+    const formattedAmountIn = formatUnits(amountIn, inputTokenData?.decimals);
+    const liquidityProviderPercent = getLiquidityProviderFeePercent(chainId, inputTokenAddress, outputTokenAddress);
+    return {
+        value: (Number(formattedAmountIn) * liquidityProviderPercent) / 100,
+        symbol: inputTokenData?.symbol,
+    };
+};
+const getSwappedAmount = async (chainId, inputTokenAddress, outputTokenAddress, amount) => {
+    const readProvider = createReadOnlyProvider(chainId);
+    const katanaContract = createKatanaContract(chainId);
+    const swapConfig = getSwapConfig(chainId, outputTokenAddress);
+    const path = swapConfig[inputTokenAddress]?.path;
+    const response = await katanaContract.connect(readProvider).getAmountsIn(amount, path);
+    return response?.[0];
+};export{getLiquidityProviderFee,getLiquidityProviderFeePercent,getPriceImpactPercent,getSwappedAmount};