Uniswap/Pancakeswap – How to Lock Liquidity Tokens Efficiently

liquidity-providerpancakeswapuniswap

Tell me how to Lock liquidity on Pancakeswap or Uniswap ?

Best Answer

You can block liquidity + this you will increase confidence in front of investors, I block now at openlock.io/ref/31, no problems.

Short answer

Given a liquidity pool with token A and token B, let:

reserve_a_initial be the amount of token A in the liquidity pool before the trade
reserve_b_initial be the amount of token B in the liquidity pool before the trade (not required to calculate the price impact)
fee be the trading fee. For PancakeSwap, this is 0.0025
amount_traded be the amount of token A traded

To calculate the price impact:

amountInWithFee = amount_traded * (1 - fee);
price_impact = amountInWithFee / (reserve_a_initial + amountInWithFee);

Explanation

This article explains how to calculate the price impact. However, please note that what the article refers to as the "current market price" or "market rate", I refer to as the mid_price. Now, let's calculate the price_impact:

constant_product = reserve_a_initial * reserve_b_initial;
reserve_b_after_execution = constant_product / (reserve_a_initial + amountInWithFee);
amountOut = reserve_b_initial - reserve_b_after_execution;
market_price = amountInWithFee / amountOut;
mid_price = reserve_a_initial / reserve_b_initial;
price_impact = 1 - (mid_price / market_price);

Before substituting and simplifying, let:

reserve_a_initial be $r_{a0}$
reserve_b_initial be $r_{b0}$
reserve_b_after_execution be $r_{b1}$
amount_traded be $a_{traded}$
fee be $f$
amountInWithFee be $a_{in}$
constant_product be $k$
amountOut be $a_{out}$
market_price be $p_{market}$
mid_price be $p_{mid}$
price_impact be $price_{impact}$

Now for the math:

$a_{in} = a_{traded}(1-f)$

$k = r_{a0} \cdot r_{b0}$

$r_{b1} = \frac{k}{r_{a0} + a_{in}} = \frac{r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}}$

$a_{out} = r_{b0} - r_{b1} = r_{b0} - \frac{r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}} = \frac{r_{b0}(r_{a0} + a_{in}) - r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}} = \frac{r_{b0} \cdot a_{in}}{r_{a0} + a_{in}}$

$p_{market} = \frac{a_{in}}{a_{out}} = a_{in} \div \frac{r_{b0} \cdot a_{in}}{r_{a0} + a_{in}} = \frac{r_{a0} + a_{in}}{r_{b0}}$

$p_{mid} = \frac{r_{a0}}{r_{b0}$

$price_{impact} = 1 - \frac{p_{mid}}{p_{market}} = 1 - \frac{r_{a0}}{r_{b0}} \div \frac{r_{a0} + a_{in}}{r_{b0}} = 1 - \frac{r_{a0}}{r_{a0} + a_{in}} = \frac{a_{in}}{r_{a0} + a_{in}}$

I found this mind-blowing, but the amount of token B in the pool doesn't affect the price_impact. However, reserve_b_initial will affect amount_out.

Calculating `amount_traded` given the `price_impact`

Rearranging the price_impact equation, it is possible to calculate amount_traded for a given price_impact:

$a_{traded} = \frac{r_{a0} \cdot price_{impact}}{(1 - price_{impact})(1-f)}$

Slippage and minimum amount received

To account for slippage, s, and calculate the minimum received, amount_out_min:

amount_out_min = amount_out * (1 - s);

Slippage does not affect price_impact.

Sample code

I don't know if there's a function in a PancakeSwap contract that will directly return the price_impact, but you can get the reserves of a pool and then calculate it. Let's take CAKE-USDT as an example:

import { Contract, utils, providers } from 'ethers';
const poolAddress = '0xa39af17ce4a8eb807e076805da1e2b8ea7d0755b'; // CAKE-USDT
const poolContract = new Contract(
    poolAddress,
    ['function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast)'],
    new providers.WebSocketProvider(PROVIDER_URL)
);

poolContract.getReserves()
    .then((reserves) => {
        let reserve_a_initial = parseFloat(utils.formatUnits(reserves._reserve0));
        let reserve_b_initial = parseFloat(utils.formatUnits(reserves._reserve1));
        console.log(`CAKE in pool: ${reserve_a_initial}`);
        console.log(`USDT in pool: ${reserve_b_initial}`);

        const fee = 0.0025;
        let max_price_impact = 0.01;
        let amount_traded_cake = reserve_a_initial * max_price_impact / ((1 - max_price_impact)*(1 - fee));
        let amount_traded_usdt = reserve_b_initial * max_price_impact / ((1 - max_price_impact)*(1 - fee));
        console.log(`Given a max price impact of ${max_price_impact*100}%, the max amount of CAKE tradeable is ${amount_traded_cake}`);
        console.log(`Given a max price impact of ${max_price_impact*100}%, the max amount of USDT tradeable is ${amount_traded_usdt}`);

        let amountInCAKE = amount_traded_cake * (1 - fee);
        let amountInUSDT = amount_traded_usdt * (1 - fee);
        let price_impact_trade_cake = amountInCAKE / (reserve_a_initial + amountInCAKE);
        let price_impact_trade_usdt = amountInUSDT / (reserve_b_initial + amountInUSDT);
        console.log(`Price impact when trading ${amount_traded_cake} CAKE: ${price_impact_trade_cake*100}%`);
        console.log(`Price impact when trading ${amount_traded_usdt} USDT: ${price_impact_trade_usdt*100}%`);
    }).catch(console.error);

Sample results:

CAKE in pool: 1030240.4016832297
USDT in pool: 19974605.474162016
Given a max price impact of 1%, the max amount of CAKE tradeable is 10432.550079068678
Given a max price impact of 1%, the max amount of USDT tradeable is 202269.36507087937
Price impact when trading 10432.550079068678 CAKE: 1%
Price impact when trading 202269.36507087937 USDT: 1%

Please note that the price shown on the PancakeSwap UI is the execution_price:

execution_price = amount_traded / amountOut;

uniswap – How to Get Uniswap Liquidity Pool Addresses

There's a website for this, built and maintained by Uniswap Labs. It's info.uniswap.org:

Alternatively you might use the Uniswap V3 subgraph.

Best Answer

Related Solutions

[Ethereum] Understand price impact and liquidity in pancakeswap