(Switch only)
\
(Please read the 'Using Layer 2 networks' section at the bottom of the page.)
| | Portis | automatically shows the relevant networks to users | | Fortmatic || Supported Network | List |
|---|---|
| both Polygon and ETH (ERC-20) networks | Binance, Kucoin, Gate.io |
| Only ETH (ERC-20) network | Coinbase, OKX, Upbit, Bithumb, Coinone |
| Supports both Polygon and ETH (ERC-20) networks | Supports Only ETH (ERC-20) network |
|---|---|
| Binance, Kucoin, Gate.io | Coinbase, OKX, Upbit, Bithumb, Coinone |
| Supports both Polygon and ETH (ERC-20) networks | Supports Only ETH (ERC-20) network |
|---|---|
| Binance, Kucoin, Gate.io | Coinbase, OKX, Upbit, Bithumb, Coinone |
# Create Wallets supporting TON network Wallets that support the TON Network are TON Wallet, Tonhub, and Tonkeeper (TBD). Please refer to the user guide for more details. {% file src="/files/9TfSrpyFIBRCv7LD8kj9" %} original source: {% embed url="
1\. Click on “*Wallet*” and insert “*Toncoin(TON)*” on the token search bar. And click on “*deposit TON*”
# How to transfer TON from Huobi to the Polygon network
:ballot\_box\_with\_check: **If you wish to use TON already in your wallet (TON Network) in Meshswap, please refer to the following guide.** {% content-ref url="/pages/55hswP8TMLCLOD7eqLvg" %} [How to transfer TON from wallet to Meshswap](/get-started/how-to-move-your-assets-to-wallet/transferring-ton/how-to-transfer-ton-from-wallet-to-meshswap) {% endcontent-ref %} 1\. Log in to Huobi and click the *"Assets\_Spot"* option on the top right.
5\. Choose *“Others”* for Destination exchange. **Copy and paste the Deposit address that you copied during step 4** in the address section. Also **paste the Message (comment, payload) copied during step 4** in the Tag section. Click the *"Withdraw"* button after entering the Withdrawal Amount. {% hint style="info" %} **Minimum withdrawal amount for Huobi is 1.01 TON.** {% endhint %}
7\. In the *"security authentication"* popup, enter each verification code sent to your email and mobile device. \
8\. Select the reason for the deposit and click OK.
# Risk & Security Please aware that the use of Meshswap has the following risk factors. ● Meshswap is a **blockchain decentralized protocol without a central entity**. Users participate in transactions through liquidity pools on the blockchain created by other users at their own responsibility and judgment. This may lead to users being unable to receive recovery support from someone or Meshswap for the results of an user's mistake, so it is always recommended to test with a small amount first to manage the risk caused by mistakes(mistransfers, etc.). ● All assets and asset liquidity pools identified on the Meshswap website are tokens on the Polygon (Matic) chain that **are self-registered by users** without going through individual screening, and **their safety is not guaranteed by the Meshswap team**. ● Due to the nature of the AMM (Automated Market Maker) method, when a user exchanges an asset on the Meshswap , **the asset price applied to the user at that point may fluctuate significantly** depending on the swap size, the amount(ratio) of assets currently waiting in the pool, and real-time deposits and withdrawals of the pool. ● Asset price fluctuations may cause assets to be deposited or withdrawn from the pool at prices or ratios that users did not expect. Also, if there is a price change from the price at the time of depositing in the pool, you may incur a loss when withdrawing, compared to the case that you simply hold the asset. ● All **Figures displayed on the website are estimated information provided to help users make decisions**, and do not guarantee the timeliness, suitability or accuracy of the data. ● A normal KLAYswap website **never asks for the user's personal wallet private key, mnemonic key, and seed phrase to be entered**. ● For other risk factors, precautions, and conditions of use, please check below. ## ## 1. Abstract Meshwap is **a decentralized application (DApp)** based on Polygon (Matic) Chain which is developed by a third party. Meshwap is designed to provide users with an easy-to-use interface such as Meshswap website(
## \[Additional event: 200,000 MESH] ### **Ended event 4. \[ Korbit x Meshswap ] $MESH Airdrop Event** * Reward: Total 30,000 MESH * Event Details(Korean):\
| Terms | Definition |
|---|---|
| Pool Liquidity | The total number of assets deposited in lending pools expressed in dollar value, and an increase of the figure depends on yield for deposit |
| Total Borrowed | The total amount of assets used in a lending pool expressed in dollar value, and the figure increases with Borrow APR (%). |
| Total APR(%) | Expected earning rate from a pool is the sum of return from MESH distribution and return for deposit (MESH APR + Deposit APR) |
| Deposit APR (%) | Assets deposited by lenders are utilized as funds for leverage farmers, and interest fees paid by leverage farmers are distributed to lenders. The earnings distributed to a lender is automatically included in the quantity of my wallet deposited and can be checked in a swift manner. |
| MESH APR (%) | Lenders receive an amount of MESH determined by their respective deposit share ratio from the amount of daily Mesh pool distribution. |
| Borrow APR (%) | Assets deposited in a lending pool are utilized for leverage farm, and the leverage farmer pays the borrowing cost (interest) in return for utilizing the lending pool asset. 80% of the accumulated interest is redistributed to a lender, and 20% is used as a fund for MESH Buyback & Burn. |
| Withdrawable (amount) | It indicates a withdrawable amount of asset based on the current contract, which varies minute by minute with the scale of total deposit and total volume utilized. |
| Debt ratio(%) | The ratio of how much assets deposited in a lending pool are currently being utilized is calculated as (Total Borrowed / Pool Liquidity)*100. |
| Reserve for MESH buyback | 20% of the interest fees paid by Leverage farmers when using a lending pool asset is raised as a Reserve Fund, which is used for MESH Buyback & Burn. ＊Afterwards, the MESH Buyback quantity generated from each lending pool is automatically aggregated to determine the daily MESH distribution quantity of the pool depending on its contribution. |
#### **Transaction fee rewards** If the user supplies liquidity to the transaction fee reward pool, users can receive the transaction fee according to their LP stake (%) in the pool. The transaction fee is accrued to the Pool, and the total amount of the withdrawal includes the transaction fee reward and is processed according to the exchange rate at the time of withdrawal (50% of the transaction fee incurred).
#### **Token Airdrop rewards** If the user supplies liquidity to an airdrop reward farming pool, the Airdrop token will be distributed according to their LP share (%) in the pool.
# How to deposit your assets on Yield Farming pools 1\. Click the **\[Deposit]** menu tap at the top and go to the **\[Yield Farm]** page.  2\. Select a yield farming pool from the list and click the **\[Deposit]** button to go to the pool detail page.  3\. Enter the deposit amount.  {% hint style="info" %} **Tips** * **Making a pair of 2 tokens (A+B) deposit:**\ When you enter the quantity for one asset (A), the quantity for the other pair (B) is automatically calculated and entered. * **Making one asset (A or B) deposit:**\ The smart contract automatically swaps and deposits assets at the optimal rate corresponding to the current pool exchange rate. In order for users to acquire more of their stake in farming pool as possible, a certain amount of Token A is swapped for Token B and deposited as A + B Token pair. {% endhint %} 4\. Check the expected yield farming info in “Estimated Returns” section and click the **\[Deposit]** button to move forward. **All information shown is a real-time estimate and may differ from the actual deposit process.** Therefore, please be aware that a difference may occur during the deposit process.  {% hint style="info" %} **Tips** * **Exchange Rate:** You can check the exchange rate (price) applied when a user swaps a certain portion of the assets requested for a deposit for the remaining pair of assets.\ **＊Difference from Current Rate:** It refers to the difference (slippage) between the Exchange Rate based on the current pool status and the Exchange Rate that will applied. * **Share of pool:** It shows my estimate stake in the pool based on the current pool size. * **Daily Reward:** It shows the estimate daily MESH yield of my deposit based on the current pool's MESH APR. * **Exchange Rate Range:** Deposits are only made within ±1% of the current exchange rate. Token exchange rate may fluctuate significantly when large-scale deposits and withdrawals occur in the pool. And the exchange rate range serves as a safeguard to prevent making deposit in these unexpected token prices. Please be aware of the fluctuation range before deposit. {% endhint %} 5\. Check yield farming info from “Deposit details” pop up window and click the **\[Next]** button.  6\. In the “Transaction Confirmation” pop-up window, check the expected yield information and click the **\[Deposit]** button. Once you verify the info, click the **\[Confirm]** button in your crypto wallet.  {% hint style="info" %} **Tips** If there is no history of a selected token transaction on Meshswap, Token Approve Transaction will be preceded before Farming Transaction occurs (One time only). {% endhint %} 7\. After completing the transaction and deposit, you can check the current status of yield farming in **"Asset deposited"** at the top. Yields will be distributed in real-time after the deposit is completed.  # Leveraged Yield Farm ### About Leveraged Yield Farm  Leveraged yield farming works in a way that helps users **deposit assets in a pair by utilizing additional assets** from a lending pool. Leverage farmers can take leverage 2 - 3 times as much as their assets, allowing them to earn **much more rewards than they would have received from the yield farming pools.** **How does this profit model work?**  This profit generation with maximized capital efficiency is feasible due to the active lending pool utilization. Leverage farmers can borrow assets from lending pools on a larger scale in addition to their assets in hand, earning more various types of rewards (MESH, airdrop tokens) generated from pools. Although leveraged yield farmers are required to pay a borrowing interest to lenders, leveraged yield farmers can earn 2 -3 times more rewards than farming in other pools. Hence, leveraged yield farmers can earn more profit even after paying interest fees. ### **Determination of Leverage farm volume: leverage multiplier setting**  Users can choose the borrowing amount through the leverage multiplier settings. In order to deposit at the scale of (the dollar value of depositing assets\*leverage multiplier), a certain percentage of the borrowed asset is automatically swapped and deposited at the optimal rate. If you choose a 3x leverage multiplier when depositing 200 oUSDT, the user will deposit a total of $600 worth of MESH+oUSDT pair ($200\*3) into a pool. Leveraged yield farmers are not bound by the current exchange ratio(price) of paired assets when depositing. But Meshswap's leveraged yield farming allows users to deposit any proportion of the two tokens or even only one token. Through the smart contract, the underlying protocol will automatically swap tokens into a 50:50 split in optimal rate based on the current pool exchange rate.  You can select a leverage multiplier from the deposit menu, and check the estimate changes history in the estimation section after the deposit. ＊1.0 x leverage means without leverage, such as with standard yield farming. ### Choice of an asset to borrow  **Leveraged yield farmers can choose which assets to borrow from a lending pool.** If you choose to use oUSDT as the example above, the optimal pair deposit will be made using oUSDT equivalent to $400, and the user will proceed with a pair deposit of 150 MESH + 300 oUSDT ($600). ＊If you leverage up to 3x, when depositing 200 oUSDT (1 MATIC = 2 oUSDT, fees not reflected):\ → My asset : 200 oUSDT = $200\ → Borrowed asset: 400 oUSDT = $400 You will deposit 600 oUSDT ($600) in MESH + oUSDT pool at the optimal rate.\ → Total deposit: 150 MESH + 300 oUSDT = $ 600  You can choose which tokens to borrow from the deposit menu. After the deposit, the final estimated return will be shown in the ‘Estimated Returns’ section. Assets borrowed from a lending pool must be returned at the end of the leverage farming period (withdrawal). Including assets with some level of variability (MATIC, ETH, XRP, MESH), stable assets with little price fluctuations (USDT, USDC, DAI) can be utilized in order to pursue more stable returns. In addition, smart contracts in leveraged yield farming pools can take optimal strategies by directly depositing assets in pairs without swap or by depositing assets in pairs by swapping at a certain ratio. * The variety of lending pools will be available gradually, and slippage will be fixed at an initial rate of 1.0% (Individual settings will be provided later). ### **Managing Debt ratio**  The debt ratio (The debt-to-equity ratio) refers to **the ratio of borrowed assets to total assets deposited.** A higher debt ratio will eventually require more repayment. If the borrowing cost rises or the value of deposit asset declines due to rapid toke price fluctuation, leverage yield farmers may have difficulty repaying the borrowing. For safe asset management, Meshswap protocol sets a maximum debt ratio standard for each pool and performs liquidation when the maximum Debt ratio exceeds (Min. 85%\~Maximum 92%, Varies by a pool). Leveraged yield farmers should always be careful **not to exceed 85%\~92% of the debt ratio for safe asset management. To prevent liquidation**, you should either 1) Pay off part or all of your borrowing by withdrawing “leveraged assets” from the withdrawal tab, or 2) lower the debt ratio by depositing additional assets with a low leverage multiplier. In the case of liquidation, **the assets currently being utilized will be returned first, and the remaining balance, excluding the liquidation fee (20%), goes to the users’ wallets directly.** The accumulated liquidation fee is used as a safety fund for returning lending pool assets that have not been returned due to sudden price fluctuations. Debt ratio management and liquidation system are intended for protocol stability and smooth lending asset utilization. The liquidity supply in the lending pool can be activated only when lenders can trust the lending and leverage the yield farming system and supply more liquidity as the lending is safely returned to lending pools. In addition, **a greater liquidity supply in a lending pool offers a lower borrowing rate which helps leveraged yield farmers to borrow the lending with a lower cost (%), resulting in greater returns.** ＊Debt ratio is different for each pool. For more details, refer to the link below. {% embed url="
| Terms | Definition |
|---|---|
| Asset deposited | ‘Asset deposited’ indicates the current value of total asset deposited, a summation of my asset and leverage asset. |
| My asset | Asset deposited - borrowed asset |
| Leveraged asset | Additionally deposited asset through Leverage farm. In case of withdrawal, asset currently being borrowed would be returned using leverage asset. |
| Borrowed asset | Asset borrowed from a lending pool for Leverage farm, and at the end of Leverage farm, it must be returned including accumulated interest fee according to the asset borrowing cost (%) for each asset. |
| Debt ratio (%) | Ratio of asset borrowed to total asset deposited |
| Liquidation | If the debt ratio exceeds 85%, and from the remaining assets, users can receive the amount of asset except for the liquidation fee (20%) after the return is completed. |
| Total APR (expected) (%) | = MESH APR - borrowing cost + airdrop APR |
| MESH APR (%) | Rate of return for MESH rewards |
| Borrowing APR (%) | Annual interest cost of assets utilized by Leverage farmers, and the actual cost may vary depending on the scale of the user’s deposited assets, leverage multiplier, and the amount of assets utilized. |
| Airdrop APR (%) | Additional reward for liquidity providers of pools, and the rewards depend on the share ratio of individual users. |
### **Debt Ratio Management** An asset debt ratio is defined as the ratio of users’ borrowed assets to their total deposited assets. For safe asset management, users should make sure that the debt ratio does not exceed 90% when using long/short margin trading. In case this ratio is exceeded, returning the assets to be returned (borrowed assets) may be difficult if their prices change sharply. Therefore, when the debt ratio exceeds 90%, users’ deposited assets are automatically returned, and the remaining assets are available for withdrawal after the return is completed, excluding the 20% return fee. **In order to prevent liquidations**, users have to 1) add deposit assets in '0x' state or 2) return some of the assets they are using, and ensure that the debt ratio does not exceed 90%. Management of debt ratios and liquidations is necessary for securing protocol stability and ensuring smooth asset usage for long/short margin traders. The stable return on assets in a lending pool helps traders have faith in the system, which would in turn lead to more deposits, which would enable the supply of lending pool assets to increase. # Open and Close Long/Short Positions Here are the articles in this section: {% content-ref url="/pages/xzpWlMrjuVKmZl68GYDZ" %} [Open Long Positions](/products/long-short-margin-trading/open-and-close-long-short-positions/open-long-positions) {% endcontent-ref %} {% content-ref url="/pages/8FbI2VR1urf5FkImslEi" %} [Open Short Positions](/products/long-short-margin-trading/open-and-close-long-short-positions/open-short-positions) {% endcontent-ref %} {% content-ref url="/pages/Bb6cK99cCnabAbCSIjnu" %} [Close Long Positions](/products/long-short-margin-trading/open-and-close-long-short-positions/close-long-positions) {% endcontent-ref %} {% content-ref url="/pages/Rv2SUCd6fzyCKYwHF8At" %} [Close Short Positions](/products/long-short-margin-trading/open-and-close-long-short-positions/close-short-positions) {% endcontent-ref %} # Open Long Positions ## **Detailed procedures for opening long positions**
### Step 2 The user will use 3,000 USDC based on his or her deposit assets of 1,000 USDC. Borrowing costs are accrued at this time for the 3,000 USDC borrowed. The borrowed 3,000 USDC will be swapped for 5,982 MATIC in the MATIC/USDC pool. \* This rate is calculated based on 1 MATIC = 0.5 USDC, and a 0.3% swap fee will incur.
### Step 3 5,982 MATIC acquired through swap are deposited into a lending pool to open long positions. Before closing long position, the user may receive MESH rewards and deposit interest on 5,982 MATIC deposited in the MATIC lending pool. The following rewards and costs apply to users who have completed the long position deposit as described above. 1\) Earn USDC lending pool deposit interest on my asset 1,000 USDC (3.00% per year), Earn MESH reward 2\) Earn MATIC lending pool deposit interest on position asset 5,982 MATIC (2.00% per year), Earn MESH reward. 3\) USDT Borrowing cost for borrowed asset 3,000 USDC incurs (6.00% per year) # Open Short Positions ## **Detailed procedures for opening short positions**
### Step 2 Based on his or her deposit assets of 1,000 USDC, the user will borrow 6,000 MATIC. Borrowing costs are accumulated for the 6,000 MATIC used at this point. Borrowed 6,000 MATIC will be swapped for 2,991 USDC in MATIC/USDC pool. \* This rate is calculated based on 1 MATIC = 0.5 USDC, and a 0.3% swap fee will incur.
### Step 3 2,991 USDC acquired through swap are deposited in a USDC lending pool to open a short position. Before closing short position, the user may receive MESH rewards and deposit interest on 2,991 USDC deposited in the USDC lending pool. The following rewards and costs apply to users who have completed the short position deposit as described above. 1\) Earn USDC lending pool deposit interest on my asset 1,000 USDC (3.00% per year), Earn MESH reward 2\) Earn USDC lending pool deposit interest on secured assets 2,991 USDC (3.00% per year), Earn MESH reward. 3\) MATIC Borrowing cost for borrowd asset 6,000 MATIC incurs (7.00% per year) # Close Long Positions ## **Detailed procedures for closing short positions**
## Terminology
| Terms | Definition |
|---|---|
| Asset | Amount of assets corresponding to positions opened by users. |
| My Asset | Deposited assets used to open positions by users. The asset is deposited in a lending pool, and rewards are given based on deposit ratios. |
| Borrowed Asset | It refers to the amount of assets borrowed by users from a lending pool. Costs are incurred based on debt ratio (%). |
| Acquired Asset | It refers to assets acquired by swapping borrowed assets. Acquired Asset is deposited in a lending pool and rewards are given based on deposit ratios.
|
| Entry Price | The price applied to users when opening long/short positions. |
| Net Asset | It refers to the asset users can receive after repaying all borrowed assets. |
| PNL (Profit and Loss) | The unrealized return on the currently open position. It is calculated on the basis of the gross principal, which includes both the interest on a lending pool as well as the cost of borrowed assets. |
| ROE (Return on Equity) | The rate of return (%) compared to a user's total investment. |
| Asset Debt Ratio | Refers to the ratio (%) of borrowed assets to total deposited assets.
|
| Liquidation Price | Liquidation of the entire current position occurs when the asset debt ratio exceeds 90%. |
| Utilization Ratio | Borrwoing Rage Range | Logic |
|---|---|---|
| 0%~60% | 0%~20% | Borrowing Rate = Utilization / 3 |
| 60%~90% | 20% | Borrowing Rate = 0.2 |
| 90%~100% | 20%~100% | Borrowing Rate = Utilization * 8 - 7 |
| Type | Staking period | voting rights |
|---|---|---|
| 1X | Locked MESH for 4 months | 1 vMESH |
| 2X | Locked MESH for 8 months | 2 vMESH |
| 4X | Locked MESH for 12 months | 4 vMESH |
| 8X | Locked MESH as long as you want. You are able to unstake after 12 months of lock-up from the time of alteration(8x>4x) | 8 vMESH |
* **If you stake MESH for 12 months+α continuously**\ • Stakers can earn MESH staking rewards, airdrop token rewards, pool transaction fee rewards, and ecopot token rewards with 8x efficiency.\ • **You can change 8x to 4x efficiency whenever you want**, and you are able to unstake (withdraw) **after 12 months of lock-up from the time of alteration.** #### #### MESH inflation rewards MESH stakers can earn pool voting rights (vMESH) and MESH rewards distributed through inflation. The initial MESH distribution rate for staking participants is 40%, which can be changed through governance voting. | Distribution target | Distribution ratio by block (%) | Distribution per block (4 MESH) | Daily distribution block (4 MESH) | | ------------------------------------------------------------ | ------------------------------- | ------------------------------- | --------------------------------- | | **Lender** | 10% | 0.32 MESH | 13,824 MESH | | **Liquidity providers (General / Leverage pool depositors)** | 50% | 1.60 MESH | 69,120 MESH | | **MESH Stakers** | 40% | 1.28 MESH | 55,296 MESH | | **Total** | 100% | 3.20 MESH | 138,240 MESH | # How to stake MESH 1\. Go to the **\[Staking and Pool Voting]** page from the **\[MESH governance]** menu at the top.  2\. Click the **\[Stake]** button.  3-1. Insert **the amount** of MESH to be staked and select **the period**.  3-2. Check the expected information on the upcoming staking - the period, completion date, additional voting rights, and total APR. **All displayed information is real-time expected information, which may cause differences in the actual staking process.** Therefore, the user should be familiar with and understand the changes that may occur during the staking process.  3-3. Read the precautions carefully, agree with the terms, and then click the **\[Confirm]** and **\[Next]** buttons.  4\. Confirm the staking information lastly and click the **\[Stake]** button and the **\[Confirm]** button.  {% hint style="info" %} **Tips** If there is no history of trading selected assets on Meshswap, the Token Approve Transaction will be preceded prior to the Lending Transaction (For the first time only). {% endhint %} 5\. Once the staking is completed, ＊The staking status can be checked in "Staked Amount". ＊The real-time distributed rewards are in "Reward Amount". ＊The amount of obtained vMESH, a staking reward, can be confirmed in "My Voting Rights".  # Staking Policy #### (1) Staking policy Staking participants can join in staking according to the policy below. * MESH staking is **neither an act of entrusting nor entrusting MESH to another person. It is to lock up users' MESH asset by signing so that the MESH is not remitted or traded according to the consented terms agreed by the user themselves** (staking period, etc.). Therefore, it is **impossible to cancel, withdraw, or change the withdrawal wallet** that violates these terms. * **It is not possible to cancel staking before the end of the contractual staking period.** * Each staking contract is not separable from one another, rather, the total amount of MESH staked will be tied up based on the date of the last staking contract. It requires completing the approval procedure for your first staking contract (1st time only). * Voting rights (vMESH) can be obtained at the beginning of every staking cycle depending on the MESH quantity and contracted period (4/8/12/12+a months). * Voting rights issued after MESH staking are based on the following. * 4 months, 8 months, 12 months, and 12+α months staking give more votes corresponding to 1x, 2x, 4x, and 8x coefficients respectively. **If the selected period of additional staking is shorter than the previously selected staking period, each case will be applied to a different rate.**
Ex 1) If you stake 100 MESH for 4 months first and stake an additional 100 MESH for 12 months sequentially, a total of 800 vMESH is obtained by applying 4 times the 200 MESH.
Ex 2) If you stake 100 MESH for 12 months first and stake an additional 100 MESH for 4 months sequentially, a total of 500 vMESH is obtained by applying different multiple rates. (the first 12 months staking will get 400 vMESH while another 4 months staking will get 100 vMESH each.)
* Staking rewards are distributed proportionally according to the user’s share(%) of vMESH compared to the total vMESH. (i.e., Staking share = your vMESH/ the total number of vMESH). * If users stake MESH with an efficiency of less than 4x, you could increase the staking efficiency to 8x and obtain more vMESH through the \[maximize efficiency] button. **The 8x efficiency will continue to proceed with vMESH staking without a fixed end date until it is changed to 4x.** * If you are in the process of 8x staking, **you can lower the staking efficiency to 4x** by clicking the \[lower to 4x] button, and **you can unstake after 12 months from that point.** * If the staking efficiency is changed from 8x to 4x, due to the change in the amount of votes obtained, the pool votes in which users participated and the withdrawal of voting rights allocated to Ecopot will be prioritized. According to the pool voting policy, however, **the staking efficiency can be changed to 4x when possible to withdraw if there is a limit to the time to withdraw their voting rights at 9 a.m. (UTC+9) every day.** * **Transaction execution may be impossible due to computational costs** if the user is voting for multiple pools or participating in multiple Ecopots at the time of efficiency change. In this case, the user can directly change efficiency to 4x after withdrawing the voting rights allocated by the pool voting and Ecopot pool. * **The date and time of staking termination vary depending on the time of additional staking and the selected staking period, and unstaking (withdrawal) is possible after the staking end date.**\ \ Case 1) Existing Contract expiration date and time\ < Current time + New contract period (4/8/12 months)\ → Current time + new contract period date and time is the end date.
Case 2) Existing contract end date and time\ \> Current time + New contract period (4/8/12 months)\ → Existing contract expiration date and time is the final expiration date. * Distributed MESH rewards can be freely claimed and received in wallets. * If the existing MESH balance changes due to additional MESH staking/unstaking, any accumulated MESH rewards will be automatically claimed and sent to your wallet. #### **(2) Termination of Staking contract** * **In the case of staking with 8x efficiency, the staking continues without a fixed unstacking period.** * In the case of 4x or less staking efficiency, you can check the pop-up window for unstaking information 30 days before the end of the staking contract, and you can extend the contract or withdraw the staked funds for 30 days from the end of the staking contract. * If you unstake MESH while participating in the pool voting, the votes will be automatically withdrawn due to the return of the voting right. The amount of allocated trading fee rewards will be automatically claimed and sent to the user's wallet. * The records of voting rights and voting history will be maintained after the termination of staking. * If unstaking is not conducted within the 30-day waiting period, the new staking contract will automatically proceed based on the longest period of the previous contract (4/8/12 months) and the corresponding voting right (vMESH) will be given to the user. If the user lowers the staking efficiency to 4x during 8x staking, the user is able to unstake (withdrawal) after 12 months of lock-up from the day you change the efficiency rate. **However, automatically re-contracted staking cannot be canceled.** * If additional MESH staking is carried out within the 30 days before the staking termination period, the additional staked quantity + existing staked quantity will be deemed to have been renewed from that date. * The number of obtained vMESH will not be reduced by the pool voting. # Pool Voting Pool voting is a democratic decision-making system that determines which pool to distribute more MESHs - a powerful incentive to operate Meshswap. Only stakers with pool voting rights (vMESH) can participate, and they can receive an additional 50% of the transaction fees incurred in the pool. ### Pool Voting regulation * Users’ votes are calculated based on daily 09:00 AM (UTC+9) snapshots. * Once users vote on a specific farming pool, they can withdraw it after the upcoming snapshot period. * In the case of transaction reward pools where MESH rewards are invalidated as a result of token classification agenda voting, users can withdraw their votes for them before the upcoming snapshot period. * When the token grade is downgraded due to governance agenda voting, that specific token farming pool will be excluded from the MESH inflation reward from the point when the code is reflected. * Users can vote on farming pools that provide MESH rewards. And they can vote for up to 10 different pools. * 50% of the transaction fee generated by the voted farming pools will be distributed to the pool voters during the voting period. * The amount of the distributed transaction fee that voters will receive depends on the voters’ stake in their pool votes. (My pool voting share = my number of vMESH votes/total number of vMESHs voted for that pool) * Any farming pools without votes will not distribute the accumulated transactions fee. * Users can freely receive the distributed transaction fee reward in their wallet by clicking the get reward button. * If the number of votes held by users changes by execution of additional voting, withdrawals, and unstaking at the end of the contracted period, the distributed transaction fee will be automatically transferred to the users’ wallets at that point. # How to participate in Pool Voting with vMESH 1\. Click the **\[Staking and Pool Voting]** page on the **\[MESH governance]** menu at the top of the Meshswap.  2\. Choose the pool to vote for from the pool list, then click the **\[Deposit]** button. Users can check the total number of votes they have and the number of votes available for pool voting on ‘My Voting Rights’  3\. Insert the number of votes and check the estimated information when proceeding with Pool Voting in “Established Returns”. Click the **\[Next]** button. **All displayed information is real-time expected information, which may cause differences in the actual Pool Voting process.** Therefore, the user should be fully aware of and understand the changes that may occur during the Pool Voting process before voting.  4\. Check the pool voting information lastly, then click the **\[Vote]** button and the **\[Confirm]** button.  5\. Once the transaction is completed, ＊“Available for pool vote” shows how much vMesh is available for another pool voting. ＊“Pool voted” is for checking voting status. The distributed pool voting rewards can be confirmed from the moment the voting is completed.  # Ecopot Ecopot is an ecosystem partner project that seeks to expand users and liquidity through a connection with the Meshswap ecosystem. Ecopot project partners distribute a portion of the corresponding token inflation to stakers (vMESH holders). ### **How to participate Ecopot** MESH stakers who acquire vMESH, the voting right, can participate in Ecopot projects. Users who want to participate in Ecopot can participate in various Ecopot pools by using their vMESH, and receive token rewards from each pool. Users who stake MESH in a long period will earn more vMESH and gain more benefits from Ecopot. The allocated rewards can be checked in real time and can be received at any time. If users have participated in multiple Ecopot project pools, they can receive all rewards at once by clicking the \[Receive All Rewards] button. ### **Precautions when participating Ecopot** * Users can participate in up to 10 projects with the voting rights (vMESH) held on the Ecopot list. * Users can participate in the Ecopot based on the total amount of voting rights held, and Ecopot and pool voting are separate votes.\ Ex) Users with 1,000 vMESHs can exercise 1,000 vMESHs in each of the Ecopot and Pool voting, respectively. * The expected rate of return represents the annual rate of return (APR) after calculating the annual expected amount of rewards based on the number of vMESH participated by the user compared to the total number of total vMESH participating in the Ecopot, and it may differ from the actual rate of return. * Distributed Ecopot rewards can be received at any time. * Tokens given as rewards in Ecopot are autonomously issued tokens on the Polygon chain and have not undergone separate screening, ergo stability of the tokens are not guaranteed. * Projects are voluntarily participating in Ecopot, and Meshswap does not encourage transactions and investments in the specific token. Ecopot rewards distribution can be delayed or discontinued because the rewards are distributed to users directly by projects, not by Meshswap. * Given rewards can be found on \[Wallet] page, if not displayed, you can search for the contract address of the token. * Ecopot reward distributions are directly executed by each Ecopot project partner and rewards distribution starts from the start block. You can check the current block number in [Polygonscan ](https://polygonscan.com/)and in the top right corner (PC) or side menu (mobile) of Meshswap website. # Drops Drops is a Meshswap platform that enables various Polygon-based projects can most effectively distribute their initial token resources and successfully perform the entire process from distribution planning, implementation, and distribution for their liquidity activation. Projects can gain high attention and form a potential user pool by conducting airdrops for MESH stakers who are strong supporters of Meshswap and MESH. Projects can use this as a growth engine for future liquidity inflow, and users who participate in MESH staking can obtain staking rewards as well as opportunities and additional rewards for participating in new projects earlier than anyone else. ### **Projects** * Projects can build an initial token economy and distribute their tokens without any additional cost and resource * Projects can promote their own project contents in Meshswap community and secure new holders through airdrop * Projects can create an initial liquidity and secure liquidity suppliers by effectively exposing their contents to existing Meshswap users, and can interlock the liquidity with another project in the future * With technical support regarding smart contracts, Airdrop can be carried out transparently and safely * Mutual marketing can be conducted through consultation with Meshswap ### **MESH holders** * MESH stakers can earn additional profits in addition to MESH rewards * Without searching for multiple platforms where airdrops are held, MESH staking makes it easy to receive token airdrops distributed in Polygon ecosystem * You can preempt various financial opportunities that new projects will provide ### **Meshswap** * As more sound projects enter the Meshswap ecosystem through Drops, the Meshswap ecosystem will gradually expand, creating a virtuous cycle in which Meshswap and projects who participate in Drops grow together. Users of Meshswap can enjoy new financial opportunities provided by projects that can combine with the MESH token economy. Drops will contribute to a growth of MESH value and play an important role in the development of the Meshswap ecosystem. ### **How to participate in Drops** Users participating in MESH staking are automatically eligible for airdrops for new projects supported by Drops. There is no necessary participation procedure other than MESH staking, and airdrop tokens are distributed based on the amount of vMESH held. Users who participate in MESH staking for a long time earn more vMESHs, so the Airdrop benefit also increases. The number of airdrop rewards distributed to MESH holders can be checked based on the snapshot at 9 a.m. (UTC+9) every day, and compensation can be received at once after the end of the airdrop. ### **Precautions when participating Drops** * Airdrop will proceed with only one project for a certain period of time. * Designated airdrop rewards for each user is distributed based on a snapshot of the amount of vMESH that a user held after MESH staking. * Snapshots take place once a day at 9 a.m. (UTC+9). (However, there may be delays in snapshot processing due to situations such as increased transaction congestion and computer system errors on the Polygon chain, and in this case, vMESH snapshots are performed based on blocks at the time of recovery. Rewards are distributed according to the vMESH spotted based on the snapshot) * The 'Estimated airdrop rewards' of the ongoing AirDrop is the real-time estimated quantity calculated based on the user's vMESH quantity compared to the total amount of vMESH issued by the protocol at that time, which may not be the same as the quantity that users actually receive. The actual reward quantity is determined based on snapshots that proceed every morning. * Distributed airdrop rewards for every user can be received at once after the airdrop event is over. * Tokens provided as airdrop rewards are autonomously issued tokens on the Polygon chain and do not go through separate screening, hence safety is not guaranteed. * Airdrop is carried out autonomously by project companies, and Meshswap does not encourage the transaction or investment of a specific token. * Rewards received from airdrop can be checked on the Wallet page, and if not displayed, users can check it by searching for the token contract address * The “reward receipt date” of the distributed Drops tokens is different for each token and may be changed by the circumstances of the developer. {% content-ref url="/pages/jUbVeiekjcTv8l4JePQe" %} [Stake](/products/stake) {% endcontent-ref %} # Pool Airdrop By utilizing Meshswap's airdrop function, various Dapp projects in Polygon Chain can also freely distribute their tokens in farming pools through airdrop. If a liquidity provider supplies liquidity to an airdrop reward farming pool, the liquidity provider will receive an airdrop token set for each block based on my LP Token stake(%). Airdrop supports multiple settings in a specific farming pool, allowing users to get rewards for all multiple tokens. Meshswap aims to become a decentralized liquidity node that economically connects the Polygon ecosystem by transforming it into an organic system that connects all \[Dapp Project - Meshswap - Participants] rather than simply \[Meshswap - Participants] beyond a limited environment. ### The opportunity that token airdrop provides #### #### **(1) Stable liquidity provision environments** By providing additional rewards such as new token airdrops as well as existing transaction fees and MESH rewards, users can gain more value when supplying liquidity. This can offset the possible risks of token price changes when participating as an initial liquidity provider, which allows users to supply liquidity to Meshswap in a more stable environment than before. #### **(2) Driving the early growth of Dapp projects** The token Airdrop model can not only lead to the expansion of the unique token economy model that Dapp projects already have, but also serve as a strong incentive to maintain the intrinsic value of the project. In particular, Dapp projects that are about to grow in the Polygon ecosystem have been greatly affected by high price volatility due to a lack of initial provision of liquidity; however, in the AMM environment of Meshswap where additional rewards are made, better quality and quantity of liquidity can be provided. Therefore, projects using Meshswap can focus on increasing the original value of the project while defending short-term price volatility. Meshswap can establish an advanced incentive environment in which organic connections between liquidity providers and participants, including Dapps, can take place with additional value provision. # Governance ### Governance voting registration procedure  The order of registration and execution of the Meshswap governance vote is as follows. #### **1) Registering for voting** Users who want to register for voting in Meshswap Governance must have at least 0.1% of the total issued vMESHs in the protocol as of the time of voting registration. Voting registrants can select and register one of the types of proposals, and the registration fee is 500 MESH. MESH used for registration costs will be used to fund Buyback & Burn program. #### **2) Voting Period** The vote will be ongoing for a total of three days. After snapshotting the entire wallet at the start of the vote, the number of vMESHs that can participate in the vote for each wallet is determined. Voting rights obtained by staking additional vMESH cannot be exercised once the voting begins. You can't change the details of the vote once you exercise your right. #### **3) The first vote of approval** If the vote satisfies the minimum participation criteria and final approval criteria at the time of completion of the vote, it would be considered that the motion has been carried in the first round, and if the conditions are not met, the vote will be canceled. (1) Number of exercisable vote This is the total number of voting rights issued to the protocol based on snapshots at the time the vote began, indicating the sum of the total number of voting rights allowed to participate in the vote. (2) Minimum participation criteria. Based on the number of voting rights available, it is recognized as a valid vote only when at least the participation rate is above 30%. (3) The final approval criteria. In a case where the total voters are above the minimum participation standard and at least a majority of the total voters agree. **4) Timelock** Voting passed in the first round will remain Timelock-ed for a certain period of time. During the Timelock period, a final inspection is conducted to see if there are any problems with the execution of the transaction. **5) Final stage** When the Timelock period ends, the transaction is executed. And as the protocol code is changed, and the voting result is finally reflected. ### **Voting rights and detailed procedures** #### **1) Information on voting registration** * In order to register for voting, you must fill out a voting proposal. * Users who wish to register their votes must have at least 0.1% of the total protocol vMESH in their wallets as of the time of registration of votes, and 500 MESH will be used for voting registration (submitted 500 MESH will be used for Buyback & burn fund). #### **2) Information on voting participation** To participate in the vote, you must have a vMESH before voting begins. At the point when registered votes are exercised, the number of vMESH is snapshotted in order to identify the exact number of votes. Therefore, the voting rights obtained by staking additional MESHs after the voting began are not reflected. You can check the number of your exercisable voting rights (vMESH) by entering each voting detail page on the Meshswap governance page. As shown in the image, select the “yes” or “no” button on the voting detail page and click the “Vote” button in the transaction pop-up window to complete the voting. You can't change your decision once the vote is completed. # Governance Voting Policy * At the time of governance opening, you can vote on the matter of whether to pass or withdraw certain Grade C assets into the governance. After the initial stabilization period, sequentially scheduled updates would allow voters to exercise their voting rights on alternations of all matters. * Timeline for every governance agenda is all set to the UTC+9 timezone. * Once the vote has been registered in the governance, it cannot be changed or canceled. * Proposing multiple votes on passing the incorporation of Grade C assets into the governance with one wallet address is not possible. If you have already suggested a vote, you can suggest another vote only after the proposed vote is over. * Users who wish to register their votes must hold at least 0.1% of the total protocol vMESH in their wallets as of the time of voting registration. * The cost (500 MESH) will be incurred when registering for voting, and all of the cost will be used to fund the Buyback & Burn program. Registration costs can be changed through governance voting. * The body of the vote must be filled in at least 300 characters, including spaces, and can only be written in English. * The right to vote (vMESH) to participate in each vote will be determined through a snapshot at the start of each vote. “Reserved voting rights”shown on the governance main page indicates real-time vMESH quantities, and it may differ from the number of vMESHs that can exercise voting rights. * Even if you get more vMESHs through staking or if the number of vMESHs has decreased due to unstaking after the start of the vote, the number of vMESHs you can exercise is pre-determined at the start of the vote. * The criteria for passing a vote are as follows. If the total number of voters is above the minimum participation standard, and more than a majority of the total voters agree (see the governance vote registration\_1st approval section in case of detailed criteria). {% content-ref url="/pages/cCkbZi0tx29vZxQuM9dR" %} [Governance](/products/governance) {% endcontent-ref %} * The criteria for rejecting a vote are as follows. \- In the case of participating less than the minimum number of voting rights until the end of the voting period (3 days) \- In a case where a majority of all voters do not approve at the end of the voting period. # Contract Here are the articles in this section:thumbsup: {% content-ref url="/pages/eWRKGOEEgJmhFVlaIYn7" %} [MESH](/developers/contract/mesh) {% endcontent-ref %} {% content-ref url="/pages/DINrvoJU89E1c87ksIMO" %} [MESHswapRouter](/developers/contract/meshswaprouter) {% endcontent-ref %} {% content-ref url="/pages/nryHlf05bhnMXVxZppfg" %} [Factory](/developers/contract/factory) {% endcontent-ref %} {% content-ref url="/pages/mrqzfwoaeu7foPeNS8aB" %} [Exchange](/developers/contract/exchange) {% endcontent-ref %} {% content-ref url="/pages/f0gdbXs6yqQN8yTAiMeU" %} [PoolVoting](/developers/contract/poolvoting) {% endcontent-ref %} {% content-ref url="/pages/NvpZgW80dHsebfuz4lKL" %} [VotingMESH](/developers/contract/votingmesh) {% endcontent-ref %} {% content-ref url="/pages/0p4iC5AN1BDjzAOFBwkc" %} [Treasury](/developers/contract/treasury) {% endcontent-ref %} {% content-ref url="/pages/u3CfGyZbROswRu7y6WEQ" %} [Distribution](/developers/contract/distribution) {% endcontent-ref %} {% content-ref url="/pages/xOR2foWFxl920l0ww90W" %} [Governor](/developers/contract/governor) {% endcontent-ref %} {% content-ref url="/pages/TVKVaxBRufuoFfQMGX4J" %} [SinglePool](/developers/contract/singlepool) {% endcontent-ref %} {% content-ref url="/pages/gGdyQGFXlG9B94VAaHjR" %} [SinglePool Factory](/developers/contract/singlepool-factory) {% endcontent-ref %} {% content-ref url="/pages/xk3U7O3Y0gbCc5Z8E5IY" %} [PlusPool Factory](/developers/contract/pluspool-factory) {% endcontent-ref %} {% content-ref url="/pages/7SeE54eAFNkW7Oo6PSis" %} [EcoPotVoting](/developers/contract/ecopotvoting) {% endcontent-ref %} {% content-ref url="/pages/wVpLdskciDqimnChxi08" %} [EcoPot](/developers/contract/ecopot) {% endcontent-ref %} # MESH The MESH smart contract is MESHswap's MESH governance token that complies with the ERC20 standard, and a smart contract that implements all functions related to MESH mining. ## Address * Polygon Mainnet : [0x82362ec182db3cf7829014bc61e9be8a2e82868a ](https://polygonscan.com/address/0x82362ec182db3cf7829014bc61e9be8a2e82868a) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **Transfer** ```solidity event Transfer(address indexed from, address indexed to, uint amount); ``` * Event for the movement and burning of MESH tokens * A ERC-20 Standard Event **Approval** ```solidity event Approval(address indexed holder, address indexed spender, uint amount); ``` * Event for MESH token approval * A ERC-20 Standard Event **RefixMining** ```solidity event RefixMining(uint blockNumber, uint newBlockAmount, uint newHalfLife); ``` * Event for MESH mining option change * Events that can occur depending on the block creation time of the polygon network {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### name * Meshswap Protocol #### symbol * MESH #### decimals * 18 #### totalSupply * Amount of MESH distributed so far * Max Supply = 126144000 + 1500000 - Burn MESH #### balanceOf * The amount of MESH held in each address #### allowance * Status of approval to spender for each address #### owner * Governance Contract Address #### miningAmount * The total mining amount * This cannot be changed after a contract is deployed #### halfLife * The block unit that proceeds with halving * This cannot be changed after a contract is deployed #### minableBlock * The block number that starts mining #### teamRatio * The ratio of the mined amount given to the developement team. #### teamWallet * The address to which the development team can claim their reward #### teamAward * The team reward amount that has already been claimed #### mined ```solidity function mined() public view returns (uint) ``` * Returns the MESH amount mined so far * This amount includes the quantity already claimed and the quantity to be claimed * The teamAward quantity is exempted from this amount {% endtab %} {% tab title="State-Changing Functions" %} #### transfer ```solidity function transfer(address _to, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to transfer MESH tokens #### transferFrom ```solidity function transferFrom(address _from, address _to, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to transfer tokens on behalf of the approved wallet #### approve ```solidity function approve(address _spender, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to approve a transfer as much as value to spender {% endtab %} {% endtabs %} # MESHswapRouter The swap router supports all the basic requirements of a front-end offering trading. The functions supported by default can be checked in the table below. ## Address * Polygon Mainnet : [0x10f4a785f458bc144e3706575924889954946639](https://polygonscan.com/address/0x10f4a785f458bc144e3706575924889954946639) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events #### #### ExchangePos ```solidity event ExchangePos(address token0, uint amount0, address token1, uint amount1); ``` * Positive exchange Event * parameters * `token0` : User input token0 address * `amount0` : User input token0 amount * `token1` : User get token1 address * `amount1` : User get token1 amount #### ExchangeNeg ```solidity event ExchangeNeg(address token0, uint amount0, address token1, uint amount1); ``` * Negative exchange Event * parameters * `token0` : User input token0 address * `amount0` : User input token0 amount * `token1` : User get token1 address * `amount1` : User get token1 amount ## {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### factory * Factory Contract Address **WETH** * WETH Contract Address #### quote ```solidity function quote(uint amount0, uint reserve0, uint reserve1) internal pure returns (uint amount1); ``` * Given some asset amount and reserves, returns an amount of the other asset representing equivalent value. #### getAmountIn ```solidity function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn); ``` * Returns the minimum input asset amount required to buy the given output asset amount (accounting for fees) given reserves. #### getAmountOut ```solidity function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut); ``` * Given an input asset amount, returns the maximum output amount of the other asset (accounting for fees) given reserves. **getAmountsIn** ```solidity function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts); ``` * Given an output asset amount and an array of token addresses, calculates all preceding minimum input token amounts by calling getReserves for each pair of token addresses in the path in turn, and using these to call getAmountIn. #### getAmountsOut ```solidity function getAmountsOut(uint amountIn, address[] memory path) internal view returns (uint[] memory amounts); ``` * Given an input asset amount and an array of token addresses, calculates all subsequent maximum output token amounts by calling getReserves for each pair of token addresses in the path in turn, and using these to call getAmountOut. {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions **addLiquidity** ```solidity function addLiquidity( address token0, address token1, uint amount0Desired, uint amount1Desired, uint amount0Min, uint amount1Min, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); ``` * Adds liquidity to an ERC-20 / ERC-20 pool. * To cover all possible scenarios, `msg.sender` should have already given the router an allowance of at least amount0Desired/amount1Desired on token0/token1. * Always adds assets at the ideal ratio, according to the price when the transaction is executed. * If a pool for the passed tokens does not exists, one is created automatically, and exactly amount0Desired/amount1Desired tokens are added. * Parameters * `token0` : A pool token. * `token1` : A pool token. * `amount0Desired` : The amount of token0 to add as liquidity if the token1/token0 price is <= amount1Desired/amount0Desired . * `amount1Desired`: : The amount of tokenB to add as liquidity if the token0/token1 price is <= amountADesired/amountBDesired . * `amount0Min` : Bounds the extent to which the B/A price can go up before the transaction reverts. Must be <= amount0Desired. * `amount1Min` : Bounds the extent to which the A/B price can go up before the transaction reverts. Must be <= amount1Desired. * `to` : Recipient of the liquidity tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amount0` : The amount of token0 sent to the pool. * `amount1`: The amount of token1 sent to the pool. * `liquidity` : The amount of liquidity tokens minted. **addLiquidityETH** ```solidity function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); ``` * Adds liquidity to an ERC-20 / WETH pool with ETH. * To cover all possible scenarios, `msg.sender` should have already given the router an allowance of at least amountTokenDesired on token. * Always adds assets at the ideal ratio, according to the price when the transaction is executed. * `msg.value` is treated as a amountETHDesired. * Leftover ETH, if any, is returned to `msg.sender`. * If a pool for the passed token and WETH does not exists, one is created automatically, and exactly amountTokenDesired/`msg.value` tokens are added. * Parameters * `token` : A pool token. * `amountTokenDesired` : The amount of token to add as liquidity if the WETH/token price is <= `msg.value`/amountTokenDesired. * `amountETHDesired`: : The amount of ETH to add as liquidity if the token/WETH price is <= amountTokenDesired/`msg.value`. * `amountTokenMin` : Bounds the extent to which the WETH/token price can go up before the transaction reverts. Must be <= amountTokenDesired. * `amountETHMin` : Bounds the extent to which the token/WETH price can go up before the transaction reverts. Must be <= `msg.value`. * `to` : Recipient of the liquidity tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amountToken` : The amount of token sent to the pool. * `amountETH`: The amount of ETH converted to WETH and sent to the pool. * `liquidity` : The amount of liquidity tokens minted. **removeLiquidity** ```solidity function removeLiquidity( address token0, address token1, uint liquidity, uint amount0Min, uint amount1Min, address to, uint deadline ) external returns (uint amount0, uint amount1); ``` * Removes liquidity from an ERC-20 / ERC-20 pool. * `msg.sender` should have already given the router an allowance of at least liquidity on the pool. * Parameters * `token0` : A pool token. * `token1` : A pool token. * `liquidity` : The amount of liquidity tokens to remove. * `amount0Min` : The minimum amount of tokenA that must be received for the transaction not to revert.. * `amount1Min` : The minimum amount of tokenB that must be received for the transaction not to revert. * `to` : Recipient of the underlying assets. * `deadline` : Unix timestamp after which the transaction will revert. * `amount0` : The amount of token0 received. * `amount1`: The amount of token1 received. **removeLiquidityETH** ```solidity function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); ``` * Removes liquidity from an ERC-20 / WETH pool and receive ETH. * `msg.sender` should have already given the router an allowance of at least liquidity on the pool. * Parameters * `token` : A pool token. * `liquidity` : The amount of liquidity tokens to remove. * `amountTokenMin` : The minimum amount of token that must be received for the transaction not to revert. * `amountETHMin` : The minimum amount of ETH that must be received for the transaction not to revert. * `to` : Recipient of the underlying assets. * `deadline` : Unix timestamp after which the transaction will revert. * `amount0` : The amount of token received. * `amount1`: The amount of ETH received. **removeLiquidityWithPermit** ```solidity function removeLiquidityWithPermit( address token0, address token1, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amount0, uint amount1); ``` * Removes liquidity from an ERC-20 / ERC-20 pool without pre-approval * Parameters * `token0` : A pool token. * `token1` : A pool token. * `liquidity` : The amount of liquidity tokens to remove. * `amount0Min` : The minimum amount of token0 that must be received for the transaction not to revert. * `amount1Min` : The minimum amount of token1 that must be received for the transaction not to revert. * `to` : Recipient of the underlying assets. * `deadline` : Unix timestamp after which the transaction will revert. * `approveMax` : Whether or not the approval amount in the signature is for liquidity or uint(-1). * `v` : The v component of the permit signature. * `r` : The r component of the permit signature. * `s` : The s component of the permit signature. * `amount0` : The amount of token0 received. * `amount1` : The amount of token1 received. **removeLiquidityETHWithPermit** ```solidity function removeLiquidityWithPermit( address token0, address token1, uint liquidity, uint amount0Min, uint amount1Min, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amount0, uint amount1); ``` * Removes liquidity from an ERC-20 / WETTH pool and receive ETH without pre-approva * Parameters * `token` : A pool token. * `liquidity` : The amount of liquidity tokens to remove. * `amountTokenMin` : The minimum amount of token that must be received for the transaction not to revert. * `amountETHMin` : The minimum amount of ETH that must be received for the transaction not to revert. * `to` : Recipient of the underlying assets. * `deadline` : Unix timestamp after which the transaction will revert. * `approveMax` : Whether or not the approval amount in the signature is for liquidity or uint(-1). * `v` : The v component of the permit signature. * `r` : The r component of the permit signature. * `s` : The s component of the permit signature. * `amountToken` : The amount of token received. * `amountETH` : The amount of ETH received. **swapExactTokensForTokens** ```solidity function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` * Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * `msg.sender` should have already given the router an allowance of at least amountIn on the input token. * Parameters * `amountIn` : The amount of input tokens to send. * `amountOutMin` : The minimum amount of output tokens that must be received for the transaction not to revert. * `path` : An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the output tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **swapTokensForExactTokens** ```solidity function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` * Receive an exact amount of output tokens for as few input tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * `msg.sender` should have already given the router an allowance of at least amountInMax on the input token. * Parameters * `amountOut` : The amount of output tokens to send. * `amountInMax` : The maximum amount of input tokens that can be required before the transaction reverts. * `path` : An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the output tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **swapExactETHForTokens** ```solidity function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` * Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * Parameters * `amountIn` : The amount of ETH to send. * `amountOutMin` : The minimum amount of output tokens that must be received for the transaction not to revert. * `path` : An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the output tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **swapTokensForExactETH** ```solidity function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` * Receive an exact amount of ETH for as few input tokens as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * `msg.sender` should have already given the router an allowance of at least amountInMax on the input token. * If the to address is a smart contract, it must have the ability to receive ETH. * Parameters * `amountOut` : The amount of output ETH to send. * `amountInMax` : The maximum amount of input tokens that can be required before the transaction reverts. * `path` : An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the ETH. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **swapExactTokensForETH** ```solidity function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` * Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * If the to address is a smart contract, it must have the ability to receive ETH. * Parameters * `amountIn` : The amount of tokens to send. * `amountOutMin` : The minimum amount of output tokens that must be received for the transaction not to revert. * `path` : An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the output ETH. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **swapETHForExactTokens** ```solidity function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` * Receive an exact amount of tokens for as little ETH as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist). * Leftover ETH, if any, is returned to `msg.sender`. * Parameters * `amountOut` : The amount of tokens to receive. * `amountInMax` : The maximum amount of ETH that can be required before the transaction reverts. * `path` : An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. * `to` : Recipient of the output tokens. * `deadline` : Unix timestamp after which the transaction will revert. * `amounts` : The input token amount and all subsequent output token amounts. **claimReward** ```solidity function claimReward(address pair, uint deadline) external ``` * Method that a user calls to claim the claimable MESH that has accumulated for the pair * When called, MESH is claimed from the Factory contract and paid to `msg.sender` * Parameters * `pair` : Pairs that paid liquidity. * `deadline` : Unix timestamp after which the transaction will revert. **claimReward** ```solidity function claimReward(address token0, address token1, uint deadline) external ``` * Method that a user calls to claim the claimable MESH that has accumulated for the pair * When called, MESH is claimed from the Factory contract and paid to `msg.sender` * Parameters * `token0` : token0 address of pairs that paid liquidity. * `token1` : token1 address of pairs that paid liquidity. * `deadline` : Unix timestamp after which the transaction will revert. {% endtab %} {% endtabs %} # MESHSwapView This contract can check asset details and exchange estimates of meshswap service ## Address * Polygon Mainnet : [0xF61e4ede9128A9FA9a128cB7D161F4e73bd464Da](https://polygonscan.com/address/0xF61e4ede9128A9FA9a128cB7D161F4e73bd464Da) {% tabs %} {% tab title="Read-Only Functions" %} ## Read-Only Functions **getPoolData** ```solidity function getPoolData(address lp) public view returns ( uint miningRate, uint rateDecimals, address token0, uint reserveA, address token1, uint reserveB, uint airdropCount, address[] memory airdropTokens, uint[] memory airdropSettings ) ``` * Details of the pool * Airdrop only between startBlock and endBlock of blocks in the network * Parameters * `miningRate` : MESH distribution ratio numerator value * `rateDecimals` : MESH distribution ratio denominator * 예) Daily MESH distribution ratio * miningRate - 130323276365080043, rateDecimals - 10000000000000000 * 130323276365080043 / 10000000000000000 = 13.03...% * `token0` : LP token0 * `reserveA` : Amount of token0 held by LP * `token1` : LP token1 * `reserveB` : Amount of token1 held by LP * `airdropCount` : Number of airdrop plans in progress at LP * `airdropTokens` : Airdrop token address array * `airdropSettings` : Airdrop info array * \[0]: blockAmount, \[1]: startBlock, \[2]: endBlock * `airdropSettings` Data format * 예) Token0, Token1 Airdrop * airdropTokens = \[ Token0 address, Token1 address] * airdropSettings = \[ Token0 blockAmount, Token0 startBlock, Token0 endBlock, Token1 blockAmount, Token1 startBlock, Token1 endBlock ] **getPendingReward** ```solidity function getPendingReward(address lp, address user) public view returns ( uint meshReward, uint airdropCount, address[] memory airdropTokens, uint[] memory airdropRewards ) ``` * User's claimable reward information * Parameters * `meshReward` : Claimable MESH * `airdropCount` : Number of airdrop plans the LP has * `airdropTokens` : Airdrop token address array * `airdropRewards` : Arrangement of Airdrop token amount Information claimable * `airdrop` data format * 예) Token0, Token1 Airdrop * airdropTokens = \[ Token0 address, Token1 address] * airdropSettings = \[ Token0 reward, Token1 reward ] **estimateSwap** ```solidity function estimateSwap( uint amountIn, address[] memory path ) public view returns (uint amountOut) ``` * MESHswap swap estimate lookup function * Input Parameters * `amountIn` : Token amount to be exchanged * `path` : exchange token path * example * WMATIC -> MESH * amountIn = 1000000000000000000 ( =1 WMATIC ) * path = `["0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270", "0x82362Ec182Db3Cf7829014Bc61E9BE8a2E82868a"]` * WMATIC -> USDC -> MESH * path = `["0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270", "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", "0x82362Ec182Db3Cf7829014Bc61E9BE8a2E82868a"]` {% endtab %} {% endtabs %} # Factory The Factory smart contract oversees the full functionality of token pair registration and transactions in MESHswap. ## Address * Polygon Mainnet :[ ](https://scope.klaytn.com/account/0xc6a2ad8cc6e4a7e08fc37cc5954be07d499e7654?tabId=txList)[0x9f3044f7f9fc8bc9ed615d54845b4577b833282d](https://polygonscan.com/address/0x9f3044f7f9fc8bc9ed615d54845b4577b833282d) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events #### ChangeCreateFee ```solidity event ChangeCreateFee(uint _createFee); ``` * An event to change the Pool Contract Creation Fee when adding a new liquidity pool pair #### CreatePool ```solidity event CreatePool(address token0, uint amount0, address token1, uint amount1, uint fee, address exchange, uint exid); ``` * Event to create new liquidity pool * parameters * `token0` : token0 address in pair * `amount0` : token0 amount in pool * `token1` : token1 address in pair * `amount1` : token1 amount in pool * `fee` : pool fee rate * `exchange` : exchange contract address of this pool * `exid` : exchange id {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### WETH * WETH contract address. #### mesh * MESH contract address #### allPairsLength * Returns the total number of pairs created through the factory so far. #### getPoolCount * Returns the total number of pairs created through the factory so far. #### createFee * The amount of MESH that must be paired to create a new liquidity pool pair #### owner * Factory Contract Address #### nextOwner * The next Governance Contract Address set in advance. #### pools * List of liquidity pool pairings * Each item saves the smart contract address of the liquidity pool #### poolExist * Returns if the contract for the given liquidiy pool pair exists #### tokenToPool * The contract address corresponding to the token0, token1 pair * When the addresses of token0 and token1 are inputted, this returns the contract address of the corresponding pairing * Returns the same contract address regardless of the order of the liquidity pool pairing tokens: tokenToPool\[token0]\[token1] == tokenToPool\[token1]\[token0] #### #### allPairs ``` function allPairs(uint) external view returns (address pair); ``` * Returns the address of the `n`th pair (`0`-indexed) created through the factory #### getPair ``` function getPair(address token0, address token1) external view returns (address pair); ``` * Returns the address of the pair for `token0` and `token1`, if it has been created, else `address(0)` (`0x0000000000000000000000000000000000000000`). #### getPoolAddress ``` function getPoolAddress(uint idx) public view returns (address) ``` * Returns the address of the `n`th pair (`0`-indexed) created through the factory {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### createETHPool ```solidity function createETHPool(address token, uint amount, uint fee) public payable ``` * A method called to add a liquidity pair with one side as MATIC * The wallet that calls this must have MESH greater than or equal to createFee * Token for when the WMATIC / ERC-20 pair to be registered has never been registered before * Parameters * `token` : ERC-20 token address to add liquidity * `amount` : the amount of tokens (ERC-20) to be provided for the initial liquidity * `fee` : Sets the initial fee value for liquidity pairs * A value between 0 and 100 * Meaning: 0 -> 0%, 100 -> 1% * `msg.value` : MATIC quantity to initially supply liquidity * Delivers the transaction value without specifying otherwise #### createTokenPool ```solidity function createTokenPool(address token0, uint amount0, address token1, uint amount1, uint fee) public ``` * Method called to add liquidity pair in case of ERC-20 token pair * The wallet calling the MESH above createFee must have it. * parameter * `token0` : The address of the first token * `amount0` : The quantity of the first token that supplies the initial liquidity * `token1` : The address of the second token * `amount1` : The quantity of the second token that supplies the initial liquidity * `fee` : Sets the initial fee value for liquidity pairs {% endtab %} {% endtabs %} # Exchange This is a smart contract to expand ERC-20 that is created with every liquidity pair. The Factory deploys this as new pool creation is requested. Although the Factory actually stores the two tokens of a pair and swapping takes place through it, the Exchange Contract must be called for liquidity to be provided or taken. ## Code Github Link: (Will be updated after official launch) ## Address Contract address after production is deployed ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events #### Transfer ```solidity event Transfer(address indexed from, address indexed to, uint amount); ``` * ERC-20 Standard * Event log of Transfer/Mint/Burn #### Approval ```solidity event Approval(address indexed holder, address indexed spender, uint amount); ``` * ERC-20 Standard * Event log of Approvals #### ChangeMiningRate ```solidity event ChangeMiningRate(uint _mining); ``` * Event log of mining rate change #### ChangeFee ```solidity event ChangeFee(uint _fee); ``` * Event log of trading fee rate changes #### ChangeRateNumerator ```solidity event ChangeRateNumerator(uint rateNumerator); ``` * Event log of rateNumerator changes #### UpdateMiningIndex ```solidity event UpdateMiningIndex(uint lastMined, uint miningIndex); ``` * Event log of pairs’ mining index changes * `lastMined` : Factory.mined() value at the time index is updated * `miningIndex` : pairs’ miningIndex value at the time #### GiveReward ```solidity event GiveReward(address user, uint amount, uint lastIndex, uint rewardSum); ``` * Event log of when mined MESH is claimed and distributed * `user` : address of the user who claimed * `amount` : the amount of MESH claimed * `lastIndex` : index result of the pair of the wallet after claiming * `rewardSum` : The amount of MESH that has been accrued so far #### ExchangePos ```solidity event ExchangePos(address token0, uint amount0, address token1, uint amount1); ``` * Event log of POS transactions * `token0` : Token address delivered by the user * `amount0` : the amount of tokens delivered by the user * `token1` : token address received by user * `amount1` : the amount of tokens received by the user #### ExchangeNeg ``` event ExchangeNeg(address token0, uint amount0, address token1, uint amount1); ``` * Event log of NEG transactions * `token0` : token address delivered by the user * `amount0` : the amount of tokens delivered by the user * `token1` : token address received by the user * `amount1` : the amount of tokens received by the user #### AddLiquidity ``` event AddLiquidity(address user, address token0, uint amount0, address token1, uint amount1, uint liquidity); ``` * Event log of liquidity additions * `liquidity` : the amount of LP tokens minted due to additional liquidity #### RemoveLiquidity ``` event RemoveLiquidity(address user, address token0, uint amount0, address token1, uint amount1, uint liquidity); ``` * Event log of liquidity removals * `liquidity` : the amount of LP tokens burned due to liquidity removal **Sync** ``` event Sync(uint112 reserveA, uint112 reserveB); ``` * Emitted each time reserves are updated. * Parameters * pool : Pool contract address of target pool * reserveA : Token0 liquidity amount * reserveB : Token1 liquidity amount {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### name * Meshswap LP #### symbol * MSLP #### decimals * 18 #### totalSupply * mint/burn depending on liquidity addition/removal #### balanceOf * Number of LP tokens held by each address #### allowance * Status of approval to spender for each address #### factory * The factory address where the LP smart contract is deployed #### token0 * The first token address composed of the pair #### token1 * The second token address composed of the pair **reserve0** * Returns the liquidity quantity of the token0 asset in the current pool **reserve1** * Returns the liquidity quantity of the token1 asset in the current pool #### fee * Transaction fee for the pair * It is a value between 0 and 100, in units of 0.01% * 1 == 0.01%, 100 == 1% #### mining * The mining rate of the pair * It is a value between 0 and 100, in units of 1% * e.g. If mining is 10, the pair has claim authority for 10% of the quantity mined per block in the factory. #### lastMined * Factory.mined() value at the last time the pair updated the index #### miningIndex * Index value of the last recorded pair #### userLastIndex * mapping(address => uint) * Stores the index value at the time of last reward for each user #### userRewardSum * mapping(address => uint ) * Stores the cumulatively claimed MESH quantity value for each user #### getCurrentPool ``` function getCurrentPool() public view returns (uint, uint) ``` * Returns the liquidity quantity of the two assets in the current pool #### estimatePos ``` function estimatePos(address token, uint amount) public view returns (uint) ``` * When a request is made to sell the amount of the corresponding token through a POS transaction, the expected receiving amount of the opposite token is returned. #### estimateNeg ``` function estimateNeg(address token, uint amount) public view returns (uint) ``` * When a request is made to purchase the amount of the corresponding token through a NEG transaction, the expected payment amount of the opposite token is returned. {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### transfer ```solidity function transfer(address _to, uint _value) public returns (bool) ``` * ERC-20 Standard #### transferFrom ```solidity function transferFrom(address _from, address _to, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to transfer tokens on behalf of the approved wallet #### approve ```solidity function approve(address _spender, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to approve transfer as much as value to the spender #### updateMiningIndex ```solidity function updateMiningIndex() public ``` * Method to update the value of the pair contract based on the current Factory.mined() value * Anyone can call in real time. Even if no one calls it, it calls itself if necessary. #### claimReward ``` function claimReward() public ``` * Method that a user calls to claim the claimable MESH that has accumulated for the pair * When called, MESH is claimed from the Factory and paid to `msg.sender` * Even if the method is not called directly, it is automatically called when the LP token balance of the user’s wallet changes. * When liquidity is added * When liquidity is removed * When LP tokens are sent * When LP tokens are received #### addETHLiquidityWithLimit ``` function addETHLiquidityWithLimit(uint amount, uint minAmount0, uint minAmount1, address user) public payable returns (uint real0, uint real1, uint amountLP) ``` * Method used to provide liquidity when token0 is MATIC * Liquidity of the MATIC `msg.value` and token1 `amount` is provided. * After liquidity is provided, the LP token corresponding to the pool share is minted in the `msg.sender` wallet. * If the pair ratio is wrong, as much liquidity as possible is supplied at the current pair ratio, and the remaining tokens are returned to `msg.sender`. * If there is claimable MESH when called, the claim proceeds to `msg.sender`. **addTokenLiquidityWithLimit** ``` function addTokenLiquidityWithLimit(uint amount0, uint amount1, uint minAmount0, uint minAmount1, address user) public nonReentrant returns (uint real0, uint real1, uint amountLP) ``` * Method used to provide liquidity when token0 is MATIC * Liquidity of the MATIC `msg.value` and token1 `amount` is provided. * Set the minimum amount of token0 and token1 to be used for liquidity supply using minAmount0, minAmount1. * After liquidity is provided, the LP token corresponding to the pool share is minted in the `msg.sender` wallet. * If the pair ratio is wrong, as much liquidity as possible is supplied at the current pair ratio, and the remaining tokens are returned to `msg.sender`. * If there is claimable MESH when called, the claim proceeds to `msg.sender`. #### removeLiquidityWithLimitETH ``` function removeLiquidityWithLimitETH(uint amount, uint minAmount0, uint minAmount1, address user) public nonReentrant returns (uint, uint) ``` * Returns the amount of LP tokens, and distributes the corresponding token0 and token1 to the msg.sender wallet * The returned LP token amount is burned * If there is claimable MESH when called, the claim proceeds to msg.sender. **removeLiquidityWithLimit** ``` function removeLiquidityWithLimit(uint amount, uint minAmount0, uint minAmount1, address user) public nonReentrant returns (uint, uint) ``` * Returns the amount of LP tokens, and distributes the corresponding token0 and token1 to the msg.sender wallet * Set the minimum amount for the returned token0 and token1 amounts by using minAmount0, minAmount1. * The returned LP token amount is burned * If there is claimable MESH when called, the claim proceeds to `msg.sender`. {% endtab %} {% endtabs %} # PoolVoting This contract manages meshswap's liquidity pool voting, pool-wide voting information, and pool voting rankings. As a reward for pool voters, 50% of pool transaction fees are distributed according to their voting stake. ## Code Github Link: (Will be updated after official launch) ## Address * Polygon Mainnet : [0x705b40af8cecd59406cf630ab7750055c9b137b9](https://polygonscan.com/address/0x705b40af8cecd59406cf630ab7750055c9b137b9) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **AddVoting** ```solidity event AddVoting(address user, address exchange, uint amount); ``` * Event log of voting vMESH for pool * The amount can be entered in integer units **RemoveVoting** ```solidity event RemoveVoting(address user, address exchange, uint amount); ``` * Event log of remove voting vMESH for pool * The amount can be entered in integer units within the voting limit. **GiveReward** ```solidity event GiveReward(address user, address exchange, address token, uint amount, uint lastIndex, uint rewardSum); ``` * Event that occurs when a transaction fee reward is paid to voters **SetValidToken** ```solidity event SetValidToken(address token, bool valid); ``` * Event that occurs when the token level is set to B through voting **SetBoostingToken** ```solidity event SetBoostingToken(address token, bool valid); ``` * Event that occurs when the token level is set to A through voting or through contract owner {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions **isValidPool** * Returns if the pool is MESH paid reward pool **MAX\_VOTING\_POOL\_COUNT** * Maximum number of pools where users can vote **poolAmount** * Total number of vMESH per LP **poolCount** * Total number of LP **poolRanking** * LP Ranking **userVotingPoolCount** * Total number of pools voted by user **validPoolCount** * Number of voting pools **boostingPowerMESH\_A** * Voting Weights for MESH and grade A tokens **boostingPowerMESH\_B** * Voting Weights for MESH and grade B tokens **boostingPowerA\_A** * Voting Weights for grade A and grade A tokens **boostingPowerA\_B** * Voting Weights for grade A and grade B tokens #### getPoolBoosting ``` function getPoolBosting(address pool) public view returns (uint) ``` * Voting Weights for target pool #### prevPoolAmount ``` function prevPoolAmount(uint256 epoch, address pool) public view returns (uint) ``` * Previous pool voting amount by epoch #### prevValidPool ``` function prevValidPool(uint256 epoch, address pool) public view returns (bool) ``` * Previous pool valid status by epoch #### isBoostingToken ``` function isBoostingToken(address token) public view returns (bool) ``` * Returns whether it is a grade A token #### isValidToken ``` function isValidToken(address token) public view returns (bool) ``` * Returns whether it is a grade A token #### userVotingPoolAmount ``` function userVotingPoolAmount(address user, uint256 poolIndex) public view returns (uint256) ``` * Number of user votes for each PoolIndex #### userVotingPoolAddress ``` function userVotingPoolAddress(address user, uint256 poolIndex) public view returns (address) ``` * Address of user votes for each PoolIndex {% endtab %} {% tab title="State-Changing Functions" %} ## **State-Changing Functions** **addVoting** ```solidity function addVoting(address exchange, uint amount) public ``` * Method to voting vMESH for pool * The amount can be entered in integer units **removeVoting** ```solidity function removeVoting(address exchange, uint amount) public ``` * Method to remove voting vMESH for pool * The amount can be entered in integer units within the voting limit **claimReward** ```solidity function claimReward(address exchange) public ``` * Method of vote pool’s transaction fee reward **claimRewardAll** ```solidity function claimRewardAll() public ``` * Method of all vote pool’s transaction fee reward **removeAllVoting** ```solidity function removeAllVoting() public ``` * Method of remove vote pool’s **delisting** ```solidity function delisting(address token) public ``` * Method of converts a grade B token to a grade C token * Automatically registered as a voting agenda after a set period of governance **setBoostingToken** ```solidity function setBoostingToken(address token, bool valid) public ``` * Method of token level set to A grade * Only governance **setValidToken** ```solidity function setValidToken(address token, bool valid) public ``` * Method of token level set to B grade * Only governance {% endtab %} {% endtabs %} # VotingMESH This contract is responsible for the ecosystem behavior related to staking MESH. Voting rights (vMESH) are issued according to the staking quantity and period, and 40% of the daily MESH mining quantity is distributed to staking participants. (MESH distribution for staking participants may be changed through governance voting) ## Code Github Link: (Will be updated after official launch)
## Address * Polygon Mainnet : [0x176b29289f66236c65c7ac5db2400abb5955df13](https://polygonscan.com/address/0x176b29289f66236c65c7ac5db2400abb5955df13) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **LockMESH** ```solidity event LockMESH(address user, uint lockPeriod, uint MESHAmount, uint totalLockedMESH, uint unlockTime); ``` * Event log of MESH staking * Parameters * `user` : user address * `lockPeriod` : * 4 months : 10,368,000 * 8 months : 20,736,000 * 12 months : 31,104,000 * x8 : 1,555,200,000 * `MESHAmount` : Number of MESH locked b * `totalLockedMESH` : Total Number of staked MESH * `unlockTime` : Available unstaking time (timestamp) **UnlockMESH** ```solidity event UnlockMESH(address user, uint vMESHAmount, uint MESHAmount); ``` * Event log of MESH unstaking * Parameters * `user` : user address * `vMESHAmount` : Number of vMESH * `MESHAmount` : Number of MESH **UnlockMESHUnlimited** ```solidity event UnlockMESHUnlimited(address user, uint vMESHBefore, uint vMESHAfter, uint MESHAmount, uint unlockTime); ``` * Event log that occurs when unstaking vMESH x8 * Parameters * `user` : user address * `vMESHBefore` : The amount of vMESH held * `vMESHAfter` : Amount of vMESH held after unstaking * `MESHAmount` : Amount of MESH staked * `unlockTime` : Available unstaking time (timestamp) **RefixBoosting** ```solidity event RefixBoosting(address user, uint lockPeriod, uint boostingAmount); ``` * Event log of staking period is changed * Parameter * `user` : user addres * `lockPeriod` : period * `boostingAmount` : Number of vMESH after period changed **ChangeMiningRate** ```solidity event ChangeMiningRate(uint _mining); ``` * Event log of daily MESH distribution rate changed **GiveReward** ```solidity event GiveReward(address user, uint amount, uint lastIndex, uint rewardSum); ``` * Event log of when mined MESH is claimed and distributed **Compound** ```solidity event Compound(address user, uint reward, uint compoundAmount, uint transferAmount, uint mintAmount); ``` * Event log of when mined MESH restaking. * The compound amount can be entered in integer units * The amount minus the compund amount from the mined amount is returned to the wallet. {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions **balanceOf** * Number of vMESH tokens held by each address **getCurrentBalance** * Number of vMESH tokens held by each address recent snapshot **getUserUnlockTime** * Possible time of unstake **lockedMESH** * Number of MESH tokens stakes **mining** * MESH distribution rate * It is a value between 0 and 10000, in units of 0.0001% **snapShotBalance** * Number of vMESH tokens held by each address and snapshot **snapShotCount** * Number of snapshot index each address **getPriorBalance** ```solidity function getPriorBalance(address user, uint blockNumber) public view returns (uint) ``` * Historical user vMESH holdings per block * Parameter * `user` : user address * `blockNumber` : prior blockNumber **snapShotBalance** ```solidity function snapShotBalance(address user, uint index) public view returns (uint) ``` * Historical vMESH holdings each address * Parameter * `user` : user address * `index` : index {% endtab %} {% tab title="State-Changing Functions" %} ## **State-Changing Functions** **lockMESH** ```solidity function lockMESH(uint amount, uint lockPeriodRequested) public ``` * Method for MESH staking * The amount can be entered in integer units **unlockMESH** ```solidity function unlockMESH() public ``` * Method for MESH unstaking * Unstaking is only possible during the unstaking period. **unlockMESHUnlimited** ```solidity function unlockMESHUnlimited() public ``` * Method for unstake MESH x8 * Changed to x4 staking from execution **refixBoosting** ```solidity function refixBoosting(uint lockPeriodRequested) ``` * Method for MESH staking period change **claimReward** ```solidity function claimReward() public ``` * Method that a user calls to claim the claimable MESH **compoundReward** ```solidity function compoundReward() public ``` * Method for mined MESH staking * Can be called when the reward is 1 MESH or more * It is possible to stake in integer units, and the rest is to the wallet address. {% endtab %} {% endtabs %} # Treasury This contract is a contract that manages airdrop operation. Operators with authority can set up and execute airdrops through Treasury Contract. ## Code Github Link: (Will be updated after official launch) ## Address * Polygon Mainnet : [0x51a4b6556b21aec229f4ca372044a505fe16ce19](https://polygonscan.com/address/0x51a4b6556b21aec229f4ca372044a505fe16ce19) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **ChangeCreationFee** ```solidity event ChangeCreationFee(uint fee); ``` * Event that occurs when the creation fee (MESH) is changed **SetOperator** ```solidity event SetOperator(address operator, bool valid); ``` * Event that occurs when setting operator **CreateDistribution** ```solidity event CreateDistribution(address operator, address token, uint totalAmount, uint blockAmount, uint blockNumber, address[] targets, uint[] rates); ``` * Event that occurs when airdrop is set **RemoveDistribution** ```solidity event RemoveDistribution(address operator, address token); ``` * Event that occurs when airdrop is removed **Deposit** ```solidity event Deposit(address operator, address token, uint amount); ``` * Event that occurs when token deposit **RefixBlockAmount** ```solidity event RefixBlockAmount(address operator, address token, uint blockAmount); ``` * Event that occurs when airdrop distribution amount **RefixDistributionRate** ```solidity event RefixDistributionRate(address operator, address token, address[] targets, uint[] rates); ``` * Event that occurs when airdrop distribution rate {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions distributionCount * Number of airdrop distributionEntries * mapping(address => mapping(uint => address)) * Number of distribution address each LP distributionOperator * mapping (address => address) * Operator address each distribution address fee * Distribution create fee owner * owner {% endtab %} {% tab title="State-Changing Functions" %} ## **State-Changing Functions** **changeCreationFee** ```solidity function changeCreationFee(uint _fee) public ``` * Method of creation fee (KSP) change * only Owner **claim** ```solidity function claim(address target) public ``` * Method that a user calls to claim the claimable airdrop tokens that has accumulated for the pair * Parameters * `target` : LP address **createTokenDistribution** ```solidity function createTokenDistribution(address token, uint amount, uint blockAmount, uint blockNumber, address[] memory targets, uint[] memory rates) public ``` * Method of ERC-20 distribution create * only Operator **depositToken** ```solidity function depositToken(address token, uint amount) public ``` * Method of ERC-20 deposit to airdrop * only Operator **refixBlockAmount** ```solidity function refixBlockAmount(address token, uint blockAmount) public ``` * Method of change the amount paid per block * only Operator **refixDistributionRate** ```solidity function refixDistributionRate(address token, address[] memory targets, uint[] memory rates) public ``` * Method of airdrop distribution rate change * only Operator **removeDistribution** ```solidity function removeDistribution(address operator, address token) public ``` * Method of airdrop distribution remove * only Operator {% endtab %} {% endtabs %} # Distribution This contract is Airdrop plan contract applied to the pool. You can target one liquidity pool and one token. The contract is executed by an operator with authority through Treasury. ## Code Github Link: (Will be updated after official launch) ## Address * Contract address after production is deployed ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **Initialized** ```solidity event Initialized(address token, uint amountPerBlock, uint distributableBlock, address[] targets, uint[] rates); ``` * Event log of airdrop created * Parameters * `token` : ERC-20 token address * `amountPerBlock` : Amount of airdrop tokens to be distributed per block * `distributableBlock` : Start block Number * `targets` : Array of liquidity pool addresses to distribute * `rates` : Array of liquidity pool distribution to distribute **Deposit** ```solidity event Deposit(uint amount, uint totalAmount); ``` * Event log of airdrop tokens deposit * Parameters * `amount` : Deposit token amount * `totalAmount` : Deposit token total amount **RefixBlockAmount** ```solidity event RefixBlockAmount(uint amountPerBlock); ``` * Event log of distribution token amount changed **RefixDistributionRate** ```solidity event RefixDistributionRate(address[] targets, uint[] rates); ``` * Event log of liquidity pool distribution rate changed **ChangeDistributionRate** ```solidity event ChangeDistributionRate(address target, uint rate); ``` * Event log of distribution rate changed **Distribute** ```solidity event Distribute(address user, address target, uint amount, uint currentIndex, uint userRewardSum); ``` * Event log of user receives an airdrop tokens * Parameters * `user` : user address * `target` : LP address * `amount` : token amount * `currentIndex` : index * `userRewardSum` : total token amount {% endtab %} {% endtabs %} # Governor This contract acts as an administrator to manage the voting registration, voting counting, and execution of the meshswap. It also performs important parameters of meshswap, proposal registration, and voting execution. ## Code Github Link: (Will be updated after official launch) ## Address * Polygon Mainnet :[ ](https://scope.klaytn.com/account/0x05343b228d61402e84d973ce114f34bc3f9e5987?tabId=txList)[0x06d057bc1129e6be214e53f04e07f1a6dcc8e390](https://polygonscan.com/address/0x06d057bc1129e6be214e53f04e07f1a6dcc8e390) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **ProposalCreated** ```solidity event ProposalCreated(uint id, address proposer, address target, string signature, bytes callData, uint startBlock, uint endBlock, string description); ``` * Events log of proposals are created * Parameters * `id` : proposal ID * `proposer` : proposer's address * `target` : Address of the contract to be executed * `signature` : signature of the function to be executed * `callData` : function data to be executed * `startBlock` : start block number * `endBlock` : end block number * `description` : proposal details **VoteCast** ```solidity event VoteCast(address voter, uint proposalId, bool support, uint votes, uint againstVotes, uint forVotes, uint quorumVotes, string reason); ``` * Events log of vote * Parameters * `voter` : voter's address * `proposalId` : proposal ID * `support` : support * `votes` : Number of vote vMESH * `againstVotes` : Number of total against vote * `forVotes` : Number of total favor vote * `quorumVotes` : Number of proposal quorum * `reason` : reason **ProposalCanceled** ```solidity event ProposalCanceled(uint id); ``` * Events log of proposal canceled **ProposalQueued** ```solidity event ProposalQueued(uint id, uint eta, uint tid); ``` * Events log of proposal queued **ProposalExecuted** ```solidity event ProposalExecuted(uint id, bool succeeded); ``` * Events log of proposal executed **ProposalFeeSet** ```solidity event ProposalFeeSet(uint oldProposalFee, uint proposalFee); ``` * Events log of proposal fee(MESH) changed {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### propose ```solidity function propose(address target, string memory signature, bytes memory callData, string memory description) public returns (uint) ``` * Function used to propose a new proposal * Sender must have delegates above the proposal threshold * `target` : Target address for proposal calls * `signature` : Function signature for proposal calls * `callData` : Calldata for proposal call * `description` : String description of the proposal #### castVote ```solidity function castVote(uint proposalId, bool support) external ``` * Function used to cast a vote for a proposal * `proposalId` : The id of the proposal to vote on * `support` : The support value for the vote. false=against, true=for {% endtab %} {% endtabs %} # SinglePool This contract is a single pool contract, where liquidity providers deposit/withdraw assets, and Plus Pool users bring or return utilized assets from a single pool. ## Code Github Link: (Will be updated after official launch) ## Address Contract address after production is deployed ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **GiveReward** ```solidity event GiveReward(address user, uint amount, uint lastIndex, uint rewardSum); ``` * Event log of when mined MESH is claimed and distributed **Deposit** ```solidity event Deposit(address user, uint depositAmount, uint depositTokens, uint totalAmount, uint totalSupply); ``` * Event log of single pool liquidity additions * Parameters * `user` : user address * `depositAmount` : amount of tokens deposited by the user * `depositTokens` : amount of single pool tokens deposited * `totalAmount` : total amount of tokens deposited * `totalSupply` : total amount of single pool tokens deposited **Withdraw** ```solidity event Withdraw(address user, uint withdrawAmount, uint withdrawTokens, uint totalAmount, uint totalSupply); ``` * Event log of single pool liquidity removals * Parameters * `user` : User address * `withdrawAmount` : The amount of tokens removed by the user * `withdrawTokens` : The amount of single pool tokens removed by the user * `totalAmount` : Total amount of tokens deposited * `totalSupply` : Total amount of single pool tokens deposited **Borrow** ```solidity event Borrow(address user, address plusPoolAddress, uint borrowAmount, uint accountBorrows, uint totalBorrows); ``` * Event log of using assets utilized during plus deposit * Parameters * `user` : user address * `plusPoolAddress` : Plus Pool address * `borrowAmount` : The amount of tokens utilized * `accountBorrows` : Total amount of assets utilized by users * `totalBorrows` : Total amount of single pool utilized **Repay** ```solidity event Repay(address user, address plusPoolAddress, uint repayAmount, uint accountBorrows, uint totalBorrows); ``` * Event log of used assets are returned * Parameters * `user` : User address * `plusPoolAddress` : PlusPool address * `repayAmount` : The amount of returned asset tokens * `accountBorrows` : Total amount of assets utilized by users * `totalBorrows` : Total amount of single pool utilized {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### name * "I" + token name #### symbol * "i" + token symbol **decimals** * 18 **token** * ERC-20 token address #### totalSupply * mint/burn depending on liquidity addition/removal #### balanceOf * Number of LP tokens held by each address #### allowance * Status of approval to spender for each address #### getCash * Number of tokens held by contract #### reserveFactor * MESH buyback & burn allocation ratio among utilization fees * It is a value between 0 and 10^18, in units of 0.000000000000000001% * Default - 200000000000000000 #### totalBorrow * Total Assets Utilized #### mining * The ratio of MESHs distributed to a single pool mined by that pool * It is a value between 0 and 10000, in units of 0.0001% #### lastMined * SinglePoolFactory.mined() value at the last time the pair updated the index #### withdrawActive ```solidity function withdrawActive() public view returns (bool) ``` * Whether single pool withdrawal is possible #### depositActive ```solidity function depositActive() public view returns (bool) ``` * Whether single pool deposit is possible {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### transfer ```solidity function transfer(address _to, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to transfer tokens #### transferFrom ```solidity function transferFrom(address _from, address _to, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to transfer tokens on behalf of the approved wallet #### approve ```solidity function approve(address _spender, uint _value) public returns (bool) ``` * ERC-20 Standard * Method to approve a transfer as much as value to spender #### depositETH ```solidity function depositETH() public payable ``` * Method used to provide liquidity when token is MATIC * Liquidity of the MATIC `msg.value` #### depositToken ```solidity function depositToken(uint depositAmount) public ``` * Method used to provide liquidity when token is ERC-20 standard token * Liquidity of the number of deposit amount is provided #### withdrawETH ```solidity function withdraw(uint withdrawAmount) ``` * Method to withdraw MATIC to `msg.sender` wallet. * `withdrawAmount` : Number of token amount to withdraw #### withdrawETHByAmount ```solidity function withdrawETHByAmount(uint withdrawTokens) ``` * Method to withdraw MATIC to `msg.sender` wallet. * `withdrawTokens` : Number of SinglePool liquidity token amount to withdraw #### withdrawToken ```solidity function withdrawToken(uint withdrawAmount) ``` * Method to withdraw tokens to `msg.sender` wallet. * `withdrawAmount` : Number of token amount to withdraw #### withdrawTokenByAmount ```solidity function withdrawTokenByAmount(uint withdrawTokens) ``` * Method to withdraw tokens to `msg.sender` wallet. * `withdrawTokens` : Number of SinglePool liquidity token amount to withdraw #### addReserves ```solidity function addReserves(uint addAmount) external payable ``` * Method to transfer tokens to using buyback MESH * `addAmount` : Number of token #### claimReward ```solidity function claimReward() public ``` * Method that a user calls to claim the claimable MESH and airdrop that has accumulated for the pair * When called, MESH is claimed from the Factory and paid to `msg.sende` * Even if the method is not called directly, it is automatically called when the SinglePool token balance of the user’s wallet changes. * When liquidity is added * When liquidity is removed {% endtab %} {% endtabs %} # SinglePool Factory This contract is a single pool creation/management contract, where liquidity providers deposit/withdraw assets, and Plus Pool users bring or return utilized assets from a single pool. ## Address * Polygon Mainnet :[ ](https://scope.klaytn.com/account/0x05343b228d61402e84d973ce114f34bc3f9e5987?tabId=txList)[0x504722a6eabb3d1573bada9abd585ae177d52e7a](https://polygonscan.com/address/0x504722a6eabb3d1573bada9abd585ae177d52e7a) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **CreatePool** ```solidity event CreatePool(address token, address pool, uint exid); ``` * Event to create new SinglePool * Parameters * `token` : A token address in target token * `pool` : SinglePool contract address of this pool * `exid` : SinglePool ID **SetDepositActive** ```solidity event SetDepositActive(address poolAddress, bool b); ``` * Event that occurs when SinglePool deposit availability is changed **SetWithdrawActive** ```solidity event SetWithdrawActive(address poolAddress, bool b); ``` * Event that occurs when SinglePool withdrawal availability is changed **ChangeMiningRate** ```solidity event ChangeMiningRate(uint _mining); ``` * Event that occurs when SinglePool mining rate is changed {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### mining * The mining rate of the pool * It is a value between 0 and 10000, in units of 0.01% * Default - 500 #### getPoolCount * Number of SinglePools #### borrowBalanceStored ```solidity function borrowBalanceStored(address token, address user, address poolAddress) public view returns (uint) ``` * Utilized asset quantity * Parameters * `token` : Token address * `user` : User address * `poolAddress` : SinglePool address {% endtab %} {% endtabs %} # PlusPool This contract manages the leveraged assets of Meshswap's plus pool liquidity providers. Liquidity providers can maximize their returns with positive assets (deposited assets + utilized assets) by using positive deposits according to their deposited assets. However, a high asset utilization ratio can result in automatic returns, which can result in losses. ## Code Github Link: (Will be updated after official launch) ## Address * Contract adress after production is deployed ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **ChangeBorrowFactor** ```solidity event ChangeBorrowFactor(uint newBorrowFactor); ``` * Event log of borrow factor change **ChangeLiquidationFactor** ```solidity event ChangeLiquidationFactor(uint newLiquidationFactor); ``` * Event log of liquidation factor change **ChangeBorrowable** ```solidity event ChangeBorrowable(address token, bool b); ``` * Event that occurs when availability is changed **GiveReward** ```solidity event GiveReward(address user, uint amount, uint lastIndex, uint rewardSum); ``` * Event log of when mined MESH is claimed and distributed * Parameters * `user` : address of the user who claimed * `amount` : the amount of MESH claimed * `lastIndex` : index result of the pair of the wallet after claiming * `rewardSum` : The amount of MESH that has been accrued so far **GiveAirdropReward** ```solidity event GiveAirdropReward(address user, address dist, uint amount, uint currentIndex, uint userAirdropSum); ``` * Event log of when airdrop token is claimed and distributed * Parameters * `user` : address of the user who claimed * `dist` : Airdrop contract address * `amount` : the amount of token claimed * `lastIndex` : index result of the pair of the wallet after claiming * `rewardSum` : The amount of token that has been accrued so far **OpenPosition** ```solidity event OpenPosition(address user, uint amount0, uint amount1, uint borrow0, uint borrow1, uint amountLP, uint userLP); ``` * Events that occur when depositing to PlusPool * If the token to deposit is MESH, `msg.value` is provided. * Parameters * `user` : address of the user * `amount0` : The deposit amount of token0 * `amount1` : The deposit amount of token1 * `borrow0` : The utilization amount of token0 * `borrow1`: The utilization amount of token1 * `amountLP`: The amount of LP tokens minted due to additional liquidity * `userLP` : the total amount of LP tokens minted due to additional liquidity **ClosePosition** ```solidity event ClosePosition(address user, uint amountLP, uint amount0, uint amount1, uint userLP); ``` * Events that occur when withdraw liquidity * Parameters * `user` : address of the user * `amountLP`: The amount of LP tokens burned due to liquidity removal * `amount0` : The withdraw amount of token0 * `amount1` : The withdraw amount of token1 * `userLP` : the total amount of LP tokens minted due to additional liquidity **Liquidate** ```solidity event Liquidate(address user, uint idx, uint debt0, uint debt1, uint lp, uint debtRatio, uint time); ``` * Event that occur when the automatic return system activates * Parameters * `user` : address of the user * `idx` : Number of auto-return count * `dept0` : Number of token0 returned automatically * `dept1` : Number of token1 returned automatically * `lp` : the total amount of LP tokens * `debtRatio` : Asset utilization ratio in case of automatic return * `time` : Automatic return time {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### totalLP * mint/burn depending on liquidity addition/removal **lpToken** * target liquidity pool address #### token0 * The first token address composed of the pair #### token1 * The second token address composed of the pair #### borrowable0 * Whether token0 can be borrowable #### borrowable1 * Whether token1 can be borrowable #### liquidationFactor * automatic return factor * It is a value between 1 and 1e18, in units of 1/1e16% * Default - 0.85e18 #### borrowFactor * Utilization cost interest rate of utilized assets * It is a value between 1 and 1e18, in units of 1/1e16% * Default - 0.67e18 #### userLP * Number of PlusPool tokens held by each address #### liquidationBonusRate * Ratio of resources to be used for MESH buyback & incineration in case of automatic return #### liquidationCount ```solidity function liquidationCount(address user) public view returns (uint) ``` * Returns the user's cumulative automatic return count {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### claimReward ```solidity function claimReward() public ``` * Method that a user calls to claim the claimable MESH that has accumulated for the pair * When called, MESH is claimed from the Factory and paid to msg.sender * Even if the method is not called directly, it is automatically called when the LP token balance of the user’s wallet changes. * When liquidity is added * When liquidity is removed #### openPositionETH ```solidity function openPositionETH(uint amount1, uint borrow0, uint borrow1, uint minAmountLP) public payable ``` * Method that depositing MATIC to PlusPool * After liquidity is provided, the LP token corresponding to the pool share is minted in the `msg.sender` wallet. * If there is claimable MESH when called, the claim proceeds to `msg.sender`. * Parameter * `amount1` : The deposit amount of token1 * `borrow0` : The utilization amount of WMATIC * `borrow1`: The utilization amount of token1 * `minAmountLP` : Minimum Guaranteed LP amount #### openPositionToken ```solidity function openPositionToken(uint amount0, uint amount1, uint borrow0, uint borrow1, uint minAmountLP) public payable ``` * Method that depositing to PlusPool * After liquidity is provided, the LP token corresponding to the pool share is minted in the `msg.sender` wallet. * If there is claimable MESH when called, the claim proceeds to `msg.sender`. * Parameter * `amount0` : The deposit amount of token0 * `amount1` : The deposit amount of token1 * `borrow0` : The utilization amount of token0 * `borrow1`: The utilization amount of token1 * `minAmountLP` : Minimum Guaranteed LP amount #### closePositionETH ```solidity function closePositionETH(uint amountLP, uint minAmount0, uint minAmount1) public ``` * Returns the amount of LP tokens, and distributes the corresponding MATIC and token1 to the `msg.sender` wallet * The returned LP token amount is burned * If there is claimable MESH and Airdrop when called, the claim proceeds to `msg.sender`. * Parameters * `amountLP`: The amount of LP tokens burned due to liquidity removal * `minAmount0` : The withdraw amount of token0 * `minAmount1` : The withdraw amount of token1 #### closePositionToken ```solidity function closePositionToken(uint amountLP, uint minAmount0, uint minAmount1) public ``` * Returns the amount of LP tokens, and distributes the corresponding token0 and token1 to the `msg.sender` wallet * The returned LP token amount is burned * If there is claimable MESH and Airdrop when called, the claim proceeds to `msg.sender`. * Parameters * `amountLP`: The amount of LP tokens burned due to liquidity removal * `minAmount0` : The withdraw amount of token0 * `minAmount1` : The withdraw amount of token1 {% endtab %} {% endtabs %} # PlusPool Factory This contract creates PlusPools and manages the state of each PlusPool. ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **CreatePool** ```solidity event CreatePool(address token0, address token1, address lpToken, uint borrowFactor, uint liquidationFactor, bool borrowable0, bool borrowable1, address poolAddress, uint exid); ``` * Event to create new PlusPool * Parameters * `token0` : token0 address in LP * `token1` : token1 address in LP * `lpToken` : address in LP * `borrowFactor` : Utilization cost interest rate of utilized assets * `liquidationFactor` : automatic return factor * `borrowable0` : Whether token0 can be borrowable * `borrowable1` : Whether token1 can be borrowable * `poolAddress` : PlusPool contract address of this pool * `exid` : PlusPool id **SetDepositActive** ```solidity event SetDepositActive(address plusPoolAddress, bool b); ``` * Event that occurs when PlusPool deposit availability is changed **SetWithdrawActive** ```solidity event SetWithdrawActive(address plusPoolAddress, bool b); ``` * Event that occurs when PlusPool withdrawal availability is changed {% endtab %} {% endtabs %} # EcoPotVoting This contract is creating and managing of the EcoPot project and exercising voting rights for the EcoPot project. MESH staking users vote for the EcoPot project they want and receive tokens according to their stake. ## Address * Polygon Mainnet : [0x13c5c5a5d418b5365fb30ca1ec8a9fb2a6f622d1](https://polygonscan.com/address/0x13c5c5a5d418b5365fb30ca1ec8a9fb2a6f622d1) {% tabs %} {% tab title="Event" %} **CreateEcoPot** ```solidity event CreateEcoPot(address operator, address ecoPot, address token, string name); ``` * Event log of EcoPot created * Parameters * `operator` : EcoPotOperator address * `ecoPot` : EcoPot address * `token` : Token address received by user * `name` : EcoPot Project name **RemoveEcoPot** ```solidity event RemoveEcoPot(address ecoPot); ``` * Event that occurs when EcoPot is removed **ChangeEcoPotAvailable** ```solidity event ChangeEcoPotAvailable(address ecoPot, bool b); ``` * Event that occurs when the status is changed **AddVoting** ```solidity event AddVoting(address user, address ecopot, uint amount); ``` * Event log of voting vMESH for EcoPot * Parameters * `user` : User address * `ecopot` : EcoPot address * `amount` : Vote vMESH amount **RemoveVoting** ```solidity event RemoveVoting(address user, address ecopot, uint amount); ``` * Event log of remove voting vMESH for EcoPot * Parameters * `user` : User address * `ecopot` : EcoPot address * `amount` : Unote vMESH amount {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions **ecoPotCount** * Number of EcoPot **MAX\_VOTING*****\_*****POT\_COUNT** * Maximum number of EcoPots where users can vote **ecoPotList** * mapping(uint => address) * EcoPot addresses **ecoPotExist** * mapping(address => bool) * Return if the address is EcoPot address **potTotalVotedAmount** * Total voted number of EcoPot **userVotingPotCount** * mapping(address => uint) * Number of votes each user voted for EcoPot **userVotingPotAddress** ```solidity function userVotingPotAddress(address user, uint256 ecoPotIndex) public view returns (address) ``` * EcoPot addresses voted by each user **userVotingPotAmount** ```solidity function userVotingPotAmount(address user, uint256 ecoPotIndex) public view returns (uint256) ``` * EcoPot voted amount by each user {% endtab %} {% tab title="State-Changing Functions" %} ## **State-Changing Functions** **addVoting** ```solidity function addVoting(address ecoPot, uint amount) public ``` * Method to voting vMESH for EcoPot * The amount can be entered in integer units **removeVoting** ```solidity function removeVoting(address ecoPot, uint amount) public ``` * Method to remove voting vMESH for Ecopot * The amount can be entered in integer units within the voting limit **removeAllVoting** ```solidity function removeAllVoting() public ``` * Method of remove total vote Ecopot **claimReward** ```solidity function claimReward(address ecopot) public ``` * Method of vote Ecopot’s reward **claimRewardAll** ```solidity function claimRewardAll() public ``` * Method of all vote Ecopot’s reward {% endtab %} {% endtabs %} # EcoPot EcoPot plan contract to be paid to staking users. One token can be distributed per Ecopot project, and only authorized operators can plan and proceed. ## Address Contract address after production is deployed (scope link) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events **Initialized** ```solidity event Initialized(uint totalAmount, uint amountPerBlock, uint distributableBlock, uint estimateEndBlock); ``` * Event log of Ecopot initialized * Parameters * `totalAmount` : Amount of tokens to be distribute * `amountPerBlock` : Amount of tokens to be distributed per block * `distributableBlock` : Start Block number * `estimateEndBlock` : Estimate block number of EcoPot be ended **Deposit** ```solidity event Deposit(uint amount, uint totalAmount, uint estimateEndBlock); ``` * Event log of tokens deposit * Parameters * `amount` : Deposit token amount * `totalAmount` : Deposit token total amount * `estimateEndBlock` : Estimate block number of EcoPot be ended **Removed** ```solidity event Removed(address operator, address token, uint estimateEndBlock, uint remainedBalance); ``` * Event log of Ecopot removed * Parameters * `operator` : Operator address * `token` : Token address of distributed * `estimateEndBlock` : Estimate block number of EcoPot be ended * `remainedBalance` : Token amount of remained **ChangeAvailable** ```solidity event ChangeAvailable(bool b); ``` * Event log of state changed **GiveReward** ```solidity event GiveReward(address user, uint amount, uint currentIndex, uint userRewardSum); ``` * Event log of when reward is claimed * Parameters * `user` : User address * `amount` : Amount of token claimed * `currentIndex`: Index result of the Ecopot of the wallet after claiming * `userRewardSum` : Amount of MESH that has been accrued so far {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### name * EcoPot Project name #### decimals * 18 #### token * ERC-20 token address **totalAmount** * Amount of tokens to be distribute #### getDistributedCurrent * Amount of tokens distributed #### distributableBlock * Block number to distribute start #### estimateEndBlock * Estimate block number of EcoPot be ended **amountPerBlock** * Distributed token amount per block **isAvailable** * Returns if the EcoPot is availabled **userRewardSum** * mapping(address => uint) * EcoPot reward amount by each user address {% endtab %} {% endtabs %} # Airdrop Airdrop contract is the airdrop contract stored in the Treasury when the giveReward function of the Exchange contract is called. Confirmation will distribute tokens to liquidity providers. \ **AirdropOperator** * Contract with the right to establish an Airdrop plan **Treasury** * A contract to manage assets to be used for Airdrop # Set Airdrop Operator ## 1. Contract Deploy {% tabs %} {% tab title="Deploy Guide" %} * **The LP and token to be airdropped are determined at the time of creation and cannot be modified.** * **Please check whether the Contract is deployed in the public environment.** * Please pay attention to the security of the Owner account. * Please refer to Polygon's Smart contract deployment [here](https://docs.polygon.technology/docs/develop/getting-started) {% endtab %} {% tab title="AirdropOperator Smart Contract Code" %} ``` pragma solidity 0.5.6; interface IERC20 { function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function approve(address spender, uint256 amount) external returns (bool); function decimals() external view returns (uint8); } interface IDistribution { function estimateEndBlock() external view returns (uint); function totalAmount() external view returns (uint); function blockAmount() external view returns (uint); function distributableBlock() external view returns (uint); function distribution() external view returns (uint); function targetEntries(uint) external view returns (address); function targetCount() external view returns (uint); function distributionRate(address) external view returns (uint); } interface ITreasury { function fee() external view returns (uint); function validOperator(address) external view returns (bool); function distributions(address, address) external view returns (address); function createETHDistribution(uint, uint, address[] calldata, uint[] calldata) external payable; function createTokenDistribution(address, uint, uint, uint, address[] calldata, uint[] calldata) external; function depositETH() external payable; function depositToken(address, uint) external; function refixBlockAmount(address, uint) external; function refixDistributionRate(address, address[] calldata, uint[] calldata) external; } interface IFactory { function poolExist(address) external view returns (bool); } contract AirdropOperator { // mumbai : 0x7E6863De2aAf37320d1a755FF50EB182455c8256 address constant public treasury = 0x51a4b6556b21AEC229F4Ca372044a505FE16Ce19; // mumbai : 0x48eB6bdD4ff9FeCECaf64bB2c0435ac654186386 address constant public factory = 0x9F3044f7F9FC8bC9eD615d54845b4577B833282d; // mumbai : 0x6a5d8703e612CFe33388Cf0C92d409934Fad98Cb address constant public mesh = 0x82362Ec182Db3Cf7829014Bc61E9BE8a2E82868a; address public owner; address public nextOwner; address public token; address public lp; constructor(address _token, address _lp) public { owner = msg.sender; token = _token; require(IERC20(token).decimals() != 0); lp = _lp; require(IFactory(factory).poolExist(lp)); } function version() external pure returns (string memory) { return "AirdropOperator20220415"; } // valid fallback function () payable external { revert(); } // ======================= owner method =========================== modifier onlyOwner { require(msg.sender == owner); _; } function changeNextOwner(address _nextOwner) public onlyOwner { nextOwner = _nextOwner; } function changeOwner() public { require(msg.sender == nextOwner); owner = nextOwner; nextOwner = address(0); } //withdraw tokens remaining in the operator contract function withdraw(address tokenAddr) public onlyOwner { uint balance = 0; if (tokenAddr == address(0)){ balance = (address(this)).balance; if (balance > 0){ (bool res, ) = owner.call.value(balance)(""); require(res); } } else { balance = IERC20(tokenAddr).balanceOf(address(this)); if(balance > 0) { require(IERC20(tokenAddr).transfer(owner, balance)); } } } // ====================== Stat ==================================== function getAirdropStat() public view returns ( address distributionContract, // airdrop distribution contract address uint totalAmount, // Total amount of tokens to be distributed uint blockAmount, // Amount of tokens to be distributed per block uint distributableBlock, // Block number to airdrop start uint endBlock, // Block number to airdrop end uint distributed, // Amount of tokens distributed uint remain, // amount remaining in the contract uint targetCount, // airdrop target LP count address[] memory targets, // airdrop target LP list uint[] memory rates // airdrop target lp rate list ){ distributionContract = ITreasury(treasury).distributions(address(this), token); IDistribution dis = IDistribution(distributionContract); totalAmount = dis.totalAmount(); blockAmount = dis.blockAmount(); distributableBlock = dis.distributableBlock(); endBlock = dis.estimateEndBlock(); distributed = dis.distribution(); remain = IERC20(token).balanceOf(distributionContract); targetCount = dis.targetCount(); targets = new address[](targetCount); rates = new uint[](targetCount); for(uint i = 0; i < targetCount; i++){ targets[i] = dis.targetEntries(i); rates[i] = dis.distributionRate(targets[i]); } } // ===================== Airdrop method =========================== ///@param totalAmount : Total amount of tokens to be distributed ///@param blockAmount : Amount of tokens to be distributed per block ///@param startBlock : Block number to airdrop start function createDistribution( uint totalAmount, uint blockAmount, uint startBlock ) public onlyOwner { ITreasury Treasury = ITreasury(treasury); require(Treasury.validOperator(address(this))); require(Treasury.distributions(address(this), token) == address(0)); require(startBlock >= block.number); address[] memory targets = new address[](1); targets[0] = lp; uint[] memory rates = new uint[](1); rates[0] = 100; if (Treasury.fee() > 0) { require(IERC20(mesh).balanceOf(address(this)) >= Treasury.fee()); require(IERC20(mesh).approve(treasury, Treasury.fee())); } require(IERC20(token).balanceOf(address(this)) >= totalAmount); require(IERC20(token).approve(treasury, totalAmount)); Treasury.createTokenDistribution(token, totalAmount, blockAmount, startBlock, targets, rates); } // Airdrop token deposit ///@param amount : Amount of airdrop token to deposit function deposit(uint amount) public onlyOwner { ITreasury Treasury = ITreasury(treasury); require(Treasury.validOperator(address(this))); require(Treasury.distributions(address(this), token) != address(0)); require(amount != 0); require(IERC20(token).balanceOf(address(this)) >= amount); require(IERC20(token).approve(treasury, amount)); Treasury.depositToken(token, amount); } // Airdrop amount per block modification function // The function is applied immediately from the called block ///@param blockAmount : airdrop block amount to change function refixBlockAmount(uint blockAmount) public onlyOwner { ITreasury Treasury = ITreasury(treasury); require(Treasury.validOperator(address(this))); require(Treasury.distributions(address(this), token) != address(0)); require(blockAmount != 0); Treasury.refixBlockAmount(token, blockAmount); } } ``` {% endtab %} {% endtabs %} ## 2. Contract Submission * Contact us (