Pool Finder

# observationCardinalityNext is the 5th return value of slot0
cast call <pool_address> "slot0()(uint160,int24,uint16,uint16,uint16,uint8,bool)"

# Increase cardinality for better TWAP support (anyone can call, pays gas)
cast send <pool_address> "increaseObservationCardinalityNext(uint16)" 100

IUniswapV3Factory factory = IUniswapV3Factory(0x1F98431c8aD98523631AE4a59f267346ea31F984);

address pool = factory.createPool(tokenA, tokenB, fee);

// Initialize with starting price (sqrtPriceX96 format)
// For 1 token0 = 2000 token1 (e.g., 1 ETH = 2000 USDC with 18/6 decimals):
// sqrtPriceX96 = sqrt(2000 * 1e6 / 1e18) * 2^96
uint160 sqrtPriceX96 = 3543191142285914205922034; // sqrt(2e-9) * 2^96 ≈ 3.54e24 (with equal decimals it would be sqrt(2000) * 2^96 ≈ 3.54e30)
IUniswapV3Pool(pool).initialize(sqrtPriceX96);

import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";

IPoolManager poolManager = IPoolManager(0x000000000004444c5dc75cB358380D2e3dE08A90);

PoolKey memory key = PoolKey({
    currency0: Currency.wrap(token0),
    currency1: Currency.wrap(token1),
    fee: 3000,
    tickSpacing: 60,
    hooks: IHooks(address(0))
});

poolManager.initialize(key, sqrtPriceX96);

import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {FullMath} from "v4-core/src/libraries/FullMath.sol";

/// @notice Computes sqrtPriceX96 from a human-readable price ratio
/// @param price The price of token0 in terms of token1 (e.g., 2000 for 1 ETH = 2000 USDC)
/// @param decimals0 Decimals of token0
/// @param decimals1 Decimals of token1
function computeSqrtPriceX96(
    uint256 price,
    uint8 decimals0,
    uint8 decimals1
) pure returns (uint160) {
    // rawPrice = price * 10^decimals1 / 10^decimals0   (raw token1 units per raw token0 unit)
    // sqrtPriceX96 = sqrt(rawPrice) * 2^96 = sqrt(rawPrice * 2^192)
    // Scale by 2^192 BEFORE dividing so a sub-1 rawPrice (2000e6 / 1e18 = 2e-9) does not truncate to 0;
    // FullMath.mulDiv keeps the 512-bit intermediate product from overflowing.
    uint256 priceX192 = FullMath.mulDiv(price * (10 ** decimals1), 1 << 192, 10 ** decimals0);
    return uint160(Math.sqrt(priceX192));
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Script, console2} from "forge-std/Script.sol";
import {IUniswapV3Factory} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";

contract PoolScanner is Script {
    IUniswapV3Factory constant FACTORY = IUniswapV3Factory(0x1F98431c8aD98523631AE4a59f267346ea31F984);

    function run(address tokenA, address tokenB) external view {
        uint24[4] memory fees = [uint24(100), 500, 3000, 10000];
        string[4] memory labels = ["0.01%", "0.05%", "0.30%", "1.00%"];

        for (uint256 i = 0; i < fees.length; i++) {
            address pool = FACTORY.getPool(tokenA, tokenB, fees[i]);
            if (pool != address(0)) {
                (uint160 sqrtPriceX96, int24 tick,,,,,) = IUniswapV3Pool(pool).slot0();
                uint128 liquidity = IUniswapV3Pool(pool).liquidity();
                console2.log("--- Fee Tier:", labels[i], "---");
                console2.log("  Pool:", pool);
                console2.log("  Tick:", tick);
                console2.log("  Liquidity:", liquidity);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Script, console2} from "forge-std/Script.sol";
import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";

contract TickInspector is Script {
    function run(address pool, int24 tickLower, int24 tickUpper) external view {
        IUniswapV3Pool p = IUniswapV3Pool(pool);
        int24 spacing = p.tickSpacing();
        (,int24 currentTick,,,,,) = p.slot0();

        console2.log("Current tick:", currentTick);
        console2.log("Tick spacing:", spacing);

        int24 tick = tickLower - (tickLower % spacing);
        while (tick <= tickUpper) {
            (uint128 liquidityGross, int128 liquidityNet,,,,,,) = p.ticks(tick);
            if (liquidityGross > 0) {
                console2.log("Tick:", tick);
                console2.log("  liquidityGross:", liquidityGross);
                console2.log("  liquidityNet:", liquidityNet);
            }
            tick += spacing;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Script, console2} from "forge-std/Script.sol";
import {IUniswapV3Factory} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import {IQuoterV2} from "@uniswap/v3-periphery/contracts/interfaces/IQuoterV2.sol";

contract DepthComparator is Script {
    IUniswapV3Factory constant FACTORY = IUniswapV3Factory(0x1F98431c8aD98523631AE4a59f267346ea31F984);
    IQuoterV2 constant QUOTER = IQuoterV2(0x61fFE014bA17989E743c5F6cB21bF9697530B21e);

    function run(address tokenIn, address tokenOut, uint256 amountIn) external {
        uint24[4] memory fees = [uint24(100), 500, 3000, 10000];

        for (uint256 i = 0; i < fees.length; i++) {
            address pool = FACTORY.getPool(tokenIn, tokenOut, fees[i]);
            if (pool == address(0)) continue;

            try QUOTER.quoteExactInputSingle(
                IQuoterV2.QuoteExactInputSingleParams({
                    tokenIn: tokenIn,
                    tokenOut: tokenOut,
                    amountIn: amountIn,
                    fee: fees[i],
                    sqrtPriceLimitX96: 0
                })
            ) returns (uint256 amountOut, uint160, uint32 ticksCrossed, uint256 gasEst) {
                console2.log("Fee:", fees[i]);
                console2.log("  amountOut:", amountOut);
                console2.log("  ticksCrossed:", ticksCrossed);
                console2.log("  gasEstimate:", gasEst);
            } catch {}
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Script, console2} from "forge-std/Script.sol";
import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import {IUniswapV3Factory} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import {TickMath} from "@uniswap/v3-core/contracts/libraries/TickMath.sol";

contract ArbDetector is Script {
    IUniswapV3Factory constant FACTORY = IUniswapV3Factory(0x1F98431c8aD98523631AE4a59f267346ea31F984);

    function run(address tokenA, address tokenB) external view {
        uint24[4] memory fees = [uint24(100), 500, 3000, 10000];
        int24[] memory ticks = new int24[](4);
        uint160[] memory prices = new uint160[](4);
        uint256 count;

        for (uint256 i = 0; i < fees.length; i++) {
            address pool = FACTORY.getPool(tokenA, tokenB, fees[i]);
            if (pool == address(0)) continue;
            (uint160 sqrtPriceX96, int24 tick,,,,,) = IUniswapV3Pool(pool).slot0();
            ticks[count] = tick;
            prices[count] = sqrtPriceX96;
            count++;
            console2.log("Fee:", fees[i], "Tick:", tick);
        }

        if (count >= 2) {
            int24 maxDiff;
            for (uint256 i = 0; i < count; i++) {
                for (uint256 j = i + 1; j < count; j++) {
                    int24 diff = ticks[i] > ticks[j] ? ticks[i] - ticks[j] : ticks[j] - ticks[i];
                    if (diff > maxDiff) maxDiff = diff;
                }
            }
            console2.log("Max tick divergence:", maxDiff);
            if (maxDiff > 10) {
                console2.log(">> Potential cross-fee-tier arbitrage opportunity");
            }
        }
    }
}

WETH:  0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
USDC:  0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
USDT:  0xdAC17F958D2ee523a2206206994597C13D831ec7
DAI:   0x6B175474E89094C44Da98b954EedeAC495271d0F
WBTC:  0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599
UNI:   0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984
LINK:  0x514910771AF9Ca656af840dff83E8264EcF986CA
wstETH:0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0