Uniswap Polygon UniswapV3 – How to Extract Amounts per Tick from Uniswap V3 Pool

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() 

A tick is initialized (i.e. active) if it's an endpoint of a position deployed in the pool.

Only ticks that are divisible by the pool's tick spacing can be initialized. For instance, the in 0.3% pool only ticks that are divisible by 60 can be position endpoints. (In the 0.05% pools: divisible by 10; in the 1% pools: divisible by 200.)

Uninitialized ticks still may contain liquidity. For instance, most ticks in the middle of a liquidity position are uninitialized, even though they do and contain liquidity for swapping. This includes ticks that are in the middle of a position and are divisible by 60 (or 10, or 200), unless they are the endpoints of some other position.

All uninitialized ticks have liquidityNet and liquidityGross values equal to zero. (See the v3 whitepaper for the definition of these variables.) An initialized tick may have liquidityNet equal to zero - for example, when it's the upper tick of one position with liquidity L, and the lower tick of another position with the same amount of liquidity L, since L - L = 0. However, an initialized never has liquidityGross equal to zero. Wheneven liquidityGross of an active tick becomes zero dues to a position being closes, the tick is un-initialized.