@maxion-platform/ronin-market-sdk 1.0.0

package/dist/mjs/actions/order/createOrder.js

@@ -0,0 +1,122 @@
+import {BigNumber}from'ethers';import {MARKET_FEE_PERCENTAGE}from'../../common/constants.js';import {getTokenMetadata}from'../../queries/collection/index.js';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/exchange-rate.js';import'../../queries/graphql/queries/offer.js';import'../../queries/offer/types.js';import {requestCreateOrder}from'../../queries/order/index.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import {OrderType}from'../../queries/order/types.js';import'../../queries/token/types.js';import'../../configs/index.js';import'../../services/tokens/data.js';import {checkIsErc721Approved,checkIsErc1155Approved}from'../../services/tokens/checkIsTokenApproved.js';import'lodash';import {generateInputOrder}from'../../services/order/generateOrderData.js';import {getNonce}from'../../services/order/getNonce.js';import {getErc721OrderSignature,getErc1155OrderSignature}from'../../services/order/getOrderSignature.js';import'ethers/lib/utils';import {getOrderKind}from'../../utils/mapData.js';import {ErcAssetItem}from'../../types/order.js';import {Erc}from'../../queries/collection/types.js';const generateErc721Order = (data) => {
+    const { price, duration, orderType, assets, paymentToken, maker, expectedState } = data;
+    const orderKind = getOrderKind(orderType);
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const result = {
+        maker,
+        kind: orderKind,
+        assets,
+        expiredAt,
+        paymentToken,
+        startedAt,
+        basePrice: price.toString(),
+        endedAt: 0,
+        endedPrice: '0',
+        expectedState,
+        nonce: 0,
+        marketFeePercentage: MARKET_FEE_PERCENTAGE,
+    };
+    return result;
+};
+const generateErc1155Order = (data) => {
+    const { price, duration, orderType, assets, paymentToken, maker, expectedState } = data;
+    const orderKind = getOrderKind(orderType);
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const result = {
+        maker,
+        kind: orderKind,
+        asset: assets[0],
+        expiredAt,
+        paymentToken,
+        startedAt,
+        unitPrice: price.toString(),
+        endedAt: 0,
+        endedUnitPrice: '0',
+        expectedState,
+        nonce: 0,
+    };
+    return result;
+};
+const createErc721Order = async (params) => {
+    const { chainId, wallet, tokenAddress, tokenId, paymentToken, price, duration } = params;
+    const { signer, account } = wallet;
+    const isApproved = checkIsErc721Approved(chainId, account, tokenAddress);
+    const assets = [
+        {
+            id: tokenId,
+            addr: tokenAddress,
+            erc: ErcAssetItem.Erc721,
+            quantity: 0,
+        },
+    ];
+    if (!isApproved) {
+        throw new Error('This Erc721 tokens to be approved');
+    }
+    const nonce = await getNonce(chainId, account);
+    const expectedState = '0';
+    const auctionData = {
+        price: BigNumber.from(price),
+        duration,
+        paymentToken,
+        orderType: OrderType.Sell,
+        expectedState,
+        nonce,
+        maker: account,
+        assets,
+    };
+    const inputOrder = generateInputOrder(auctionData);
+    const dataForSigning = generateErc721Order(auctionData);
+    const signature = await getErc721OrderSignature(chainId, signer, dataForSigning);
+    if (!signature) {
+        throw new Error('Invalid signature');
+    }
+    return requestCreateOrder({ order: inputOrder, signature, account, chainId });
+};
+const createErc1155Order = async (params) => {
+    const { chainId, wallet, tokenAddress, tokenId, paymentToken, price, duration, quantity } = params;
+    const { signer, account } = wallet;
+    const isApproved = checkIsErc1155Approved(chainId, account, tokenAddress);
+    const assets = [
+        {
+            id: tokenId,
+            addr: tokenAddress,
+            erc: ErcAssetItem.Erc1155,
+            quantity,
+        },
+    ];
+    if (!isApproved) {
+        throw new Error('This Erc1155 needs to be approved');
+    }
+    const nonce = await getNonce(chainId, account);
+    const expectedState = '0';
+    const auctionData = {
+        price: BigNumber.from(price),
+        duration,
+        paymentToken,
+        orderType: OrderType.Sell,
+        expectedState,
+        nonce,
+        maker: account,
+        assets,
+    };
+    const inputOrder = generateInputOrder(auctionData);
+    const dataForSigning = generateErc1155Order(auctionData);
+    const signature = await getErc1155OrderSignature(chainId, signer, dataForSigning);
+    if (!signature) {
+        throw new Error('Invalid signature');
+    }
+    return requestCreateOrder({ order: inputOrder, signature, account, chainId });
+};
+const createOrder = async (params) => {
+    const { chainId, tokenAddress } = params;
+    const tokenMetadata = await getTokenMetadata({ showAttributes: false, chainId: chainId, tokenAddress: tokenAddress });
+    const { erc } = tokenMetadata;
+    if (erc === Erc.Erc721) {
+        return createErc721Order(params);
+    }
+    return createErc1155Order({ quantity: 1, ...params });
+};export{createErc1155Order,createErc721Order,createOrder};

package/dist/mjs/actions/ron-wrapper/index.js

@@ -0,0 +1,24 @@
+import {parseUnits}from'ethers/lib/utils';import {createWRonContract}from'../../contracts/index.js';import {checkIsInsufficientBalance,checkIsInsufficientOfferBalance}from'../../services/balance/checkIsInsufficientBalance.js';import'../../configs/index.js';import {Token,wRonToken}from'../../services/tokens/data.js';import {getPaymentTokens}from'../../services/tokens/getPaymentTokens.js';import'lodash';import'ethers';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'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';const wrapRon = async (params) => {
+    const { chainId, wallet, amount, options } = params;
+    const { account, provider } = wallet;
+    const wRonContract = createWRonContract(chainId, provider);
+    const ron = getPaymentTokens(chainId)[Token.RON];
+    const formattedAmount = parseUnits(amount, ron.unit).toString();
+    const isInsufficientBalance = await checkIsInsufficientBalance(chainId, ron.address, account, formattedAmount);
+    if (isInsufficientBalance) {
+        throw new Error('Insufficient balance');
+    }
+    return wRonContract.deposit({ value: formattedAmount, ...options });
+};
+const unwrapRon = async (params) => {
+    const { chainId, wallet, amount, options } = params;
+    const { account, provider } = wallet;
+    const wRonContract = createWRonContract(chainId, provider);
+    const wRonUnit = wRonToken[chainId].unit;
+    const formattedAmount = parseUnits(amount, wRonUnit).toString();
+    const isInsufficientBalance = await checkIsInsufficientOfferBalance(chainId, account, formattedAmount);
+    if (isInsufficientBalance) {
+        throw new Error('Insufficient balance');
+    }
+    return wRonContract.withdraw(formattedAmount, { ...options });
+};export{unwrapRon,wrapRon};

package/dist/mjs/common/constants.js

@@ -0,0 +1,139 @@
+const MARKET_FEE_PERCENTAGE = 425;
+const SWAP_DEFAULT_SLIPPAGE = 1; // 1%
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const Erc1155OrderAbiTypes = {
+    Asset: [
+        {
+            name: 'erc',
+            type: 'uint8',
+        },
+        {
+            name: 'addr',
+            type: 'address',
+        },
+        {
+            name: 'id',
+            type: 'uint256',
+        },
+        {
+            name: 'quantity',
+            type: 'uint256',
+        },
+    ],
+    ERC1155Order: [
+        {
+            name: 'maker',
+            type: 'address',
+        },
+        {
+            name: 'kind',
+            type: 'uint8',
+        },
+        {
+            name: 'asset',
+            type: 'Asset',
+        },
+        {
+            name: 'expiredAt',
+            type: 'uint256',
+        },
+        {
+            name: 'paymentToken',
+            type: 'address',
+        },
+        {
+            name: 'startedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'unitPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'endedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'endedUnitPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'expectedState',
+            type: 'uint256',
+        },
+        {
+            name: 'nonce',
+            type: 'uint256',
+        },
+    ],
+};
+const OrderAbiTypes = {
+    Asset: [
+        {
+            name: 'erc',
+            type: 'uint8',
+        },
+        {
+            name: 'addr',
+            type: 'address',
+        },
+        {
+            name: 'id',
+            type: 'uint256',
+        },
+        {
+            name: 'quantity',
+            type: 'uint256',
+        },
+    ],
+    Order: [
+        {
+            name: 'maker',
+            type: 'address',
+        },
+        {
+            name: 'kind',
+            type: 'uint8',
+        },
+        {
+            name: 'assets',
+            type: 'Asset[]',
+        },
+        {
+            name: 'expiredAt',
+            type: 'uint256',
+        },
+        {
+            name: 'paymentToken',
+            type: 'address',
+        },
+        {
+            name: 'startedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'basePrice',
+            type: 'uint256',
+        },
+        {
+            name: 'endedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'endedPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'expectedState',
+            type: 'uint256',
+        },
+        {
+            name: 'nonce',
+            type: 'uint256',
+        },
+        {
+            name: 'marketFeePercentage',
+            type: 'uint256',
+        },
+    ],
+};export{Erc1155OrderAbiTypes,MARKET_FEE_PERCENTAGE,OrderAbiTypes,SWAP_DEFAULT_SLIPPAGE,ZERO_ADDRESS};

package/dist/mjs/configs/index.js

@@ -0,0 +1,72 @@
+import {SpenderContractType,ChainId}from'../types/index.js';const mainnetConfig = {
+    rpcEndpoint: 'https://api.roninchain.com/rpc',
+    chainId: 2020,
+    chainName: 'Mainnet',
+    contractsAddress: {
+        katana: '0x7d0556d55ca1a92708681e2e231733ebd922597d',
+        marketGateway: '0x3b3adf1422f84254b7fbb0e7ca62bd0865133fe3',
+        marketGatewayMultisend: '0x21a0a1c081dc2f3e48dc391786f53035f85ce0bc',
+        multiCall: '0xc76d0d0d3aa608190f78db02bf2f5aef374fc0b9',
+        collectionOffer: '0x3ef234bc2a04d86f6041e419458d9acbd077f2c1',
+        royaltyRegistry: '0x5afa3e25a620c66bb401e916680316ec80cba676',
+    },
+    marketGatewayDomain: {
+        name: 'MarketGateway',
+        version: '1',
+        chainId: 2020,
+        verifyingContract: '0x3b3adf1422f84254b7fbb0e7ca62bd0865133fe3',
+    },
+    collectionOfferDomain: {
+        name: 'CollectionOffer',
+        version: '1',
+        chainId: 2020,
+        verifyingContract: '0x3ef234bc2a04d86f6041e419458d9acbd077f2c1',
+    },
+    rnsAddress: '0x67c409dab0ee741a1b1be874bd1333234cfdbf44',
+};
+const testnetConfig = {
+    rpcEndpoint: 'https://saigon-testnet.roninchain.com/rpc',
+    chainId: 202601,
+    chainName: 'Saigon Testnet',
+    contractsAddress: {
+        katana: '0xDa44546C0715ae78D454fE8B84f0235081584Fe0',
+        marketGateway: '0x2488a13a4d635b0bacf7ef59911e54efeaf573eb',
+        marketGatewayMultisend: '0x5079b2672284570d3f56b7244f5da109c782f940',
+        multiCall: '0x31c9ef8a631e2489e69833df3b2cb4bf0dc413bc',
+        collectionOffer: '0x600d33dbf78a97c1b6a02efbebcbd7f83a04acc5',
+        royaltyRegistry: '0x7249a5d0375800189bba9dc38e7d8f613fe1c57d',
+    },
+    marketGatewayDomain: {
+        name: 'MarketGateway',
+        version: '1',
+        chainId: 202601,
+        verifyingContract: '0x2488a13a4d635b0bacf7ef59911e54efeaf573eb',
+    },
+    collectionOfferDomain: {
+        name: 'CollectionOffer',
+        version: '1',
+        chainId: 202601,
+        verifyingContract: '0x600d33dbf78a97c1b6a02efbebcbd7f83a04acc5',
+    },
+    rnsAddress: '0xf0c99c9677eda0d13291c093b27e6512e4acdf83',
+};
+const spenderContractMainnetConfig = {
+    [SpenderContractType.MarketGatewayContract]: mainnetConfig.contractsAddress.marketGateway,
+    [SpenderContractType.MarketGatewayMultiSendContract]: mainnetConfig.contractsAddress.marketGatewayMultisend,
+};
+const spenderContractTestnetConfig = {
+    [SpenderContractType.MarketGatewayContract]: testnetConfig.contractsAddress.marketGateway,
+    [SpenderContractType.MarketGatewayMultiSendContract]: testnetConfig.contractsAddress.marketGatewayMultisend,
+};
+const getConfig = (chainId) => {
+    if (chainId === ChainId.testnet) {
+        return testnetConfig;
+    }
+    return mainnetConfig;
+};
+const getSpenderContractConfig = (chainId) => {
+    if (chainId === ChainId.testnet) {
+        return spenderContractTestnetConfig;
+    }
+    return spenderContractMainnetConfig;
+};export{getConfig,getSpenderContractConfig,mainnetConfig,spenderContractMainnetConfig,spenderContractTestnetConfig,testnetConfig};

package/dist/mjs/contracts/BaseContract.js

@@ -0,0 +1,15 @@
+import {BaseContract as BaseContract$1,ethers}from'ethers';import {getConfig}from'../configs/index.js';import multiCallContractABI from'./abis/multicall.json.js';class BaseContract extends BaseContract$1 {
+    async sendMultiCallRequest(encodedFunctions, chainId) {
+        try {
+            const multiCallInterface = new ethers.utils.Interface(multiCallContractABI);
+            const data = multiCallInterface.encodeFunctionData('aggregate', [encodedFunctions]);
+            const config = getConfig(chainId);
+            const readProvider = new ethers.providers.StaticJsonRpcProvider(config.rpcEndpoint, chainId);
+            const response = await readProvider.call({ to: config.contractsAddress.multiCall, data });
+            return multiCallInterface.decodeFunctionResult('aggregate', response)._returnData;
+        }
+        catch (error) {
+            throw new Error(error.message || error);
+        }
+    }
+}export{BaseContract};

package/dist/mjs/contracts/KatanaContract.js

@@ -0,0 +1,19 @@
+import {BaseContract}from'./BaseContract.js';class KatanaContract extends BaseContract {
+    async getAmountsInMultiCall(data, chainId) {
+        try {
+            const encodedRequests = data.reduce((returnedData, currentValue) => {
+                const { amount, path } = currentValue;
+                const encodedData = this.interface.encodeFunctionData('getAmountsIn', [amount, path]);
+                return [...returnedData, [this.address, encodedData]];
+            }, []);
+            const results = await this.sendMultiCallRequest(encodedRequests, chainId);
+            return data.map((_, index) => {
+                const decodedData = this.interface.decodeFunctionResult('getAmountsIn', results[index]);
+                return decodedData[0][0];
+            });
+        }
+        catch (error) {
+            throw new Error(error.message || error);
+        }
+    }
+}export{KatanaContract};