UniswapV3 – Extracting Amounts for Non-Current Tick from Uniswap v3 Pool

polygonuniswapuniswapv3

I want to get the amounts of the tokens for a tick range which is higher or lower than the current tick.
For example I have current tick: -282986 with range [-282990, -282980], I want to get the amounts for the tick range [-282980, -282970] (next higher tick range), but I have no success.

I am using this formula:

if(sqrtPrice <= sqrtPriceLower){

    amount0 = (liquidity * ((sqrtPriceUpper - sqrtPriceLower) / (sqrtPriceLower * sqrtPriceUpper))) / Math.pow(10, 18);

}else if(sqrtPrice >= sqrtPriceUpper){

    amount1 = (liquidity * ( sqrtPriceUpper - sqrtPriceLower) ) / Math.pow(10, 6);

}else{

    amount0 = (liquidity * ((sqrtPriceUpper - sqrtPrice) / (sqrtPrice * sqrtPriceUpper))) / Math.pow(10, 18);
    amount1 = (liquidity * (sqrtPrice - sqrtPriceLower) ) / Math.pow(10, 6);

}

I have read somewhere that for this situations I need to take in calculation the liquidityNet, but I have no idea how to use it, if the information is right.

Someone can help me withe formula for ranges which are out of the current tick?

Best Answer

You can use the @uniswap/v3-core and @uniswap/v3-periphery libraries as shown in the following contract, the uniswap v3 libraries are all open source so feel free to dive into the solidity implementation code.

pragma solidity =0.7.6;

import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
import "@uniswap/v3-periphery/contracts/libraries/LiquidityAmounts.sol";

contract UniswapV3Liquidity {

    function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
        sqrtPriceX96 = TickMath.getSqrtRatioAtTick(tick);
    }

    function getAmountsForLiquidity(
        uint160 sqrtRatioX96,
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity
    ) internal pure returns (uint256 amount0, uint256 amount1) {
        (amount0, amount1) = LiquidityAmounts.getAmountsForLiquidity(
            sqrtRatioX96,
            sqrtRatioAX96,
            sqrtRatioBX96,
            liquidity            
        );
    }

    // This seems to be the function you're looking for
    function getAmountsPerUnitOfLiquidity(
        int24 currentTick,
        int24 lowerTick,
        int24 upperTick
    ) external pure returns (uint256 amount0, uint256 amount1) {
        uint160 currentSqrtPriceX96 = getSqrtRatioAtTick(currentTick);
        uint160 lowerSqrtPriceX96 = getSqrtRatioAtTick(lowerTick);
        uint160 upperSqrtPriceX96 = getSqrtRatioAtTick(upperTick);

        (amount0, amount1) = getAmountsForLiquidity(
            currentSqrtPriceX96,
            lowerSqrtPriceX96,
            upperSqrtPriceX96,
            1
        );
    }
}

Now to get the amount{0&1} per unit of liquidity minted given the current price corresponds exactly with the current tick(this is a close enough approximation in any case i.e. at most 0.01% off) you can call UniswapV3Liquidity.getAmountsPerUnitOfLiquidity(-282986, -282980, -282970) which yields the result:

{
  // since the [lowerTick, upperTick] range is above the currentTick, only token0 is required and not token1 
  "amount0": 697,
  "amount1": 0
}

Related Solutions

uniswap – How to Get Ticks Ranged Within +- of a Trade in Uniswap V3

To start here is the math for tick spacing, this will give a single active tick range

web3 style

const V3poolC = new web3.eth.Contract(V3poolabi, V3pool);
var S0 = await V3poolC.methods.slot0().call().catch(function (err){log(err)});
var CT = parseInt(S0.tick);
var Tsp = parseInt(V3poolC.methods.tickSpacing().call().catch(function (err){log(err)}));
var NLT = (math.floor(CT/Tsp))*Tsp;
var NHT = ((math.floor(CT/Tsp))*Tsp)+Tsp;
var TickL = NLT.toString();  //Nearest usable lower tick This would have the current tick range Liquidity
var TickU = NHT.toString();  //Nearest usable upper tick

So to calculate the swap you would really need to do all the liquidity math, get the token amounts in an active tick range. Then you would need to calculate the swap with those, if not enough lq in that range then you would have to include the next tick. The math on this is crazy, and there is a better way via code

The Devs made a quoter for V3 which is really awesome, and will return the active / initiated ticks crossed in a swap, along with expected output, and gas estimation.

IQuoterV2 Web3 called correctly is gasless https://docs.uniswap.org/protocol/reference/periphery/interfaces/IQuoter https://docs.uniswap.org/sdk/guides/creating-a-trade#using-callstatic-to-return-a-quote 0x61fFE014bA17989E743c5F6cB21bF9697530B21e Web3

const V3quoter = new web3.eth.Contract(V3quote, contractUNI);
let encoded = {'tokenIn':TokenIn address,'tokenOut':TokenOut address,'fee':Fee.toString(),'amountIn':AmountIn.toString(),'sqrtPriceLimitX96':'0'};
let myQuote = await V3quoter.methods.quoteExactInputSingle(encoded).call();

etherjs

var results = await IQuoterV2.Contract.callStatic.quoteExactInputSingle(encoded)

return will look like

Result {
  '0': '236927878461501597',
  '1': '2226553910065733853767841080728134',
  '2': '0',
  '3': '83578',
  amountOut: '236927878461501597',
  sqrtPriceX96After: '2226553910065733853767841080728134',
  initializedTicksCrossed: '0',
  gasEstimate: '83578'
}

Uniswap V3 Liquidity – Are Liquidity Units Fungible Across Different Price Ranges

In Uniswap V2, all liquidity provider (LP) positions fall in the price range [pa, pb] = [0, Infinity]. The value for liquidity is fungible across all positions and is calculated as follows:

This means that the value of liquidity is directly proportional to the values of x and y tokens provided, and the only way to get the same exact value of liquidity is to provide an amount of underlying tokens that falls on the curve described by the formula above.

In Uniswap V3, LP positions are more fine-tuned and have an additional level of depth. Uniswap V3 introduces the concept of concentrated liquidity, where positions are not only described by the amount of liquidity provided but also the price range [pa, pb] over which that liquidity is provided. Liquidity is described by the following formulas:

By examining the Uniswap V3 formulas, we see that the value of liquidity is directly proportional to the values of x and y and inversely proportional to the width of the price range. If we calculate the amount of liquidity that results from providing an amount of tokens x1 and y1 across a price range [pa, pb], it should be possible to get the same exact value of liquidity by providing a smaller amount of both tokens x2 and y2 across a narrower price range [pc, pd].

Therefore, in Uniswap V3, the liquidity units are not fungible across positions with different price ranges and are only locally fungible within positions that lie within the same price range.

Best Answer

Related Solutions

uniswap – How to Get Ticks Ranged Within +- of a Trade in Uniswap V3

Uniswap V3 Liquidity – Are Liquidity Units Fungible Across Different Price Ranges

Related Topic