Uniswap V3 – Why Does Uniswap Use Q Notation vs. the Uint256 Ratio Price?

uniswapuniswapv3

Question:

Why does Uniswap use Q notation versus the uint256 ratio price? A price in uniswap is always in token1/token0. Which token is which depends on the hex value assigned by the contract address when it's created.

(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);

So for example the WETH-USDC pool on ethereum the addresses are

> (WETH) 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 > (USDC) 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 
true

So WETH is token 1.

The best documentation I've found on the topic is in this article https://blog.uniswap.org/uniswap-v3-math-primer which states

Q notation specifies the parameters of the binary fixed point number
format, which allows variables to remain integers, but function
similarly to floating point numbers. Variables that must be as precise
as possible in Uniswap v3 are represented with a maximum of 256 bits
and account both for overflow and potential rounding issues. By using
Q notation, the protocol can ensure that granular decimal precision is
not lost.

My thoughts

The only upside I see, assuming that ratios have to be calculated in token1/token0 at some point and don't risk overflows as a result, is that when you store this variable which is a uinit160 (sqrtPriceX96) in a struct it takes less space and thus uses less gas than the full uint256.

And if you're not using the struct you're not gaining much of anything by using a smaller value, in fact you may even be spending more gas as seen from this stack post

"The EVM works with 256bit/32byte words (debatable design decision). Every operation is based on these base units. If your data is smaller, further operations are needed to downscale from 256 bits to 8 bits, hence why you see increased costs."

Why does uint8 cost more gas than uint256?

If someone can confirm that's the case it would be very helpful.

Best Answer

Uniswap utilizes a fixed-point number representation(Q-notation) to achieve a higher precision.

sqrtX96 means that the variable has been multiplied by 2**96 to guarantee 96 bits of precision during the computation.

Multiplying a variable by 2**96 is equivalent to shifting its bits to the left by 96 bits. During the computation, the variable now have 96 more bits with express its value. The added 96 bits will be lost in the end when the variable is divided by 2**96(shifting right 96 bits), but the added precision has been reflected to the final value.

If uint256 is used instead, some amount of precision will be lost on every step of the computation. This is because in Solidity division rounds towards zero. While the computation with fixed-point number also loses some precision, it's 96 bits more precise when compared to that of uint256.

Related Solutions

Uniswap Transfer – Why Does Uniswap V2 Use _safeTransfer to Transfer Tokens?

Because the ERC20 standard kinda sucks, and is unclear about how you should handle non-succeeding token transfers, both reverting and just returning false are technically allowed, so this takes both cases into account

(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
        // Case where there is no return data      case where there is return data
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');

if success is false, the call to the token contract reverted, and we revert the whole transaction,
if success is true and there is no return data, the token contract doesnt return anything on transfer and the transfer succeeded (this is technically non compliant with the ERC20 standard, but USDT infamously does that, which is a pain)
if success is true but there is return data, we check if it's a bool (if it's not the contract we called isnt compliant with the ERC20 standard and we revert)
- if that bool is false the transfer didnt complete and we revert
- if it's true, the transfer completed normally

Uniswap v3 – What Does ‘Price’ Mean in Uniswap v3 Trading?

So the whitepaper is great, but doesn't get into Token Decimals, since tokens will have different decimals, this must be taken into account

for tick to price (which is imprecise compared to sqrtPrice)

(1.0001**Math.abs(tick))/(10**Math.abs(token0Decimals-token1Decimals)) = Token0 price in relation to Token1

Price from sqrtPriceX96

and here is a script in mjs form, but math is extrapolatable

import { JSBI } from "@uniswap/sdk";
import { ethers } from 'ethers';
import * as fs from 'fs';

    // ERC20 abi
let ERC20Abi = fs.readFileSync('<path>/ERC20.json');
const ERC20 = JSON.parse(ERC20Abi);
    // V3 pair abi
let pool = fs.readFileSync('<path>/V3PairAbi.json');
const IUniswapV3PoolABI = JSON.parse(pool);
    // V3 factory abi
let facto = fs.readFileSync('<path>/V3factory.json');
const IUniswapV3FactoryABI = JSON.parse(facto);


const provider = new ethers.providers.JsonRpcProvider("https://eth-mainnet.alchemyapi.io/v2/<API_Key>")


const factory = "0x1F98431c8aD98523631AE4a59f267346ea31F984";


async function getPoolData(token0, token1, fee){
    const t0 = token0.toLowerCase() < token1.toLowerCase() ? token0 : token1;
    const t1 = token0.toLowerCase() < token1.toLowerCase() ? token1 : token0;
    const token0contract =  new ethers.Contract(t0, ERC20, provider);
    const token1contract =  new ethers.Contract(t1, ERC20, provider);
    const token0Decimal = await token0contract.decimals();
    const token1Decimal = await token1contract.decimals();
    const token0sym = await token0contract.symbol();
    const token1sym = await token1contract.symbol();
    const FactoryContract =  new ethers.Contract(factory, IUniswapV3FactoryABI, provider);
    const V3pool = await FactoryContract.getPool(token0, token1, fee);
    const poolContract =  new ethers.Contract(V3pool, IUniswapV3PoolABI, provider);
    const slot0 = await poolContract.slot0();
    const pairName = token0sym +"/"+ token1sym;
    return {"SqrtX96" : slot0.sqrtPriceX96.toString(), "Pair": pairName, "T0d": token0Decimal, "T1d": token1Decimal}
}


function GetPrice(testz){
    let sqrtPriceX96 = testz.SqrtX96;
    let token0Decimals = testz.T0d;
    let token1Decimals = testz.T1d;
    
    const buyOneOfToken0 = (sqrtPriceX96 * sqrtPriceX96 * (10**token0Decimals) / (10**token1Decimals) / JSBI.BigInt(2) ** (JSBI.BigInt(192))).toFixed(token1Decimals);
    const buyOneOfToken1 = (1 / buyOneOfToken0).toFixed(token0Decimals);
    console.log("price of token0 in value of token1 : " + buyOneOfToken0.toString());
    console.log("price of token1 in value of token0 : " + buyOneOfToken1.toString());
    //console.log("");
    
        // Convert to wei
    const buyOneOfToken0Wei = (Math.floor(buyOneOfToken0 * (10**token1Decimals))).toLocaleString('fullwide', {useGrouping:false});
    const buyOneOfToken1Wei = (Math.floor(buyOneOfToken1 * (10**token0Decimals))).toLocaleString('fullwide', {useGrouping:false});
    console.log("price of token0 in value of token1 in lowest decimal : " + buyOneOfToken0Wei);
    console.log("price of token1 in value of token1 in lowest decimal : " + buyOneOfToken1Wei);
    console.log("");
}


async function st(){
    const data = await getPoolData("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", "0xdAC17F958D2ee523a2206206994597C13D831ec7", 500);
    console.log(data)
    GetPrice(data)
}

st()

Best Answer

Related Solutions

Uniswap Transfer – Why Does Uniswap V2 Use _safeTransfer to Transfer Tokens?

Uniswap v3 – What Does ‘Price’ Mean in Uniswap v3 Trading?

Related Topic