Tracking Price

This guide explains how pricing works in OraclePool and how to track price changes. The key insight is that the execution price is not simply the oracle price — it's computed from both oracle data AND pool reserves.

The Pricing Model

OraclePool uses a Concentrated Liquidity Constant Product (CLCP) model. The price is determined by two components:

Oracle Data (Set by Operator)

The oracle operator sets these parameters:

Parameter	Description	Format
price (P)	Center/reference price of tokenX in tokenY	1e24 precision
alpha	Concentration factor	BPS (10000 = 1.0)
feeHbps	Trading fee	Hundred basis points (1e6 = 100%)
expiry	When the data expires	Unix timestamp

The alpha parameter defines the price range: [P/alpha, P*alpha]

For example, with alpha = 10100 (1.01 in BPS):

• If oracle price P = 1.0, the actual price can range from ~0.99 to ~1.01

Pool Reserves

The reserves (reserveX, reserveY) determine where within the price range the actual price sits.

The CLCP formula computes "virtual reserves" from real reserves + oracle params, then applies constant product pricing. As trades occur, reserves change, moving the price within the allowed range.

Oracle price alone is NOT the execution price. The oracle sets the "center" and boundaries; reserves determine the actual position within those boundaries. To compute the true execution price you need BOTH oracle data AND reserves.

Reading Oracle Data

Computing the Oracle Key

Oracle data is stored by a key derived from the token pair:

bytes32 key = keccak256(abi.encodePacked(tokenX, tokenY));

Order matters! tokenX must come first when computing the key.

Getting the Data

// On the oracle contract (get oracle address from pool.getOracle())
function getData(bytes32 key) 
    external view 
    returns (uint256 price, uint256 feeHbps, uint256 alpha, uint256 expiry);

Example usage:

address oracle = pool.getOracle();
address tokenX = pool.getTokenX();
address tokenY = pool.getTokenY();

bytes32 key = keccak256(abi.encodePacked(tokenX, tokenY));
(uint256 price, uint256 feeHbps, uint256 alpha, uint256 expiry) = IClcpOracle(oracle).getData(key);

Getting the Current Price

The ClcpOracle contract provides a function to compute the actual price:

function getCurrentPrice(bytes32 key, uint256 reserveX, uint256 reserveY) 
    external view 
    returns (uint256 priceE24);

1

How getCurrentPrice works — step 1

Reads the oracle data (price P, alpha).

2

How getCurrentPrice works — step 2

Uses the provided reserves.

3

How getCurrentPrice works — step 3

Computes the actual price using the CLCP formula.

4

How getCurrentPrice works — step 4

Returns price with 1e24 precision.

Example:

address oracle = pool.getOracle();
address tokenX = pool.getTokenX();
address tokenY = pool.getTokenY();
(uint256 reserveX, uint256 reserveY) = pool.getReserves();

bytes32 key = keccak256(abi.encodePacked(tokenX, tokenY));
uint256 priceE24 = IClcpOracle(oracle).getCurrentPrice(key, reserveX, reserveY);

// Price is tokenX denominated in tokenY with 1e24 precision
// To get human-readable: priceE24 / 1e24 * 10^(decimalsX - decimalsY)
// e.g., if priceE24 = 1.838e10, decimalsX = 18, decimalsY = 6:
// humanPrice = 1.838e10 / 1e24 * 1e12 = 0.01838 (1 tokenX = 0.01838 tokenY)

Price Format and Decimal Adjustment

The price returned is with 1e24 precision and represents the price of tokenX in terms of tokenY.

To get a human-readable price, adjust for token decimals:

humanPrice = priceE24 / 1e24 * 10^(decimalsX - decimalsY)

Example — tokenX has 18 decimals and tokenY (USDC) has 6 decimals:

// getCurrentPrice returns: 18386714238 (1.838e10)
// decimalsX = 18, decimalsY = 6

// humanPrice = 1.838e10 / 1e24 * 10^(18-6)
//            = 1.838e10 / 1e24 * 1e12
//            = 1.838e10 / 1e12
//            = 0.01838
// This means 1 tokenX = 0.01838 USDC

Another example — tokenX has 6 decimals and tokenY has 18 decimals:

// Suppose getCurrentPrice returns: 5e34
// decimalsX = 6, decimalsY = 18

// humanPrice = 5e34 / 1e24 * 10^(6-18)
//            = 5e10 * 1e-12
//            = 0.05
// This means 1 tokenX = 0.05 tokenY

Tracking Price Changes

Price can change from two sources:

Reserve Changes (Events Available)

Reserves change on:

• Swaps: Swap event

• Reallocation: Allocated event

event Swap(
    address indexed sender,
    address indexed recipient,
    bool indexed swapXtoY,
    uint256 amountIn,
    uint256 amountOut,
    uint256 feeIn
);

event Allocated(
    address indexed allocator,
    uint256 reserveX,
    uint256 reserveY
);

Watch these events to detect reserve-driven price moves.

Oracle Data Changes (No Events)

The oracle's setData() function does NOT emit events. To track oracle changes you must either watch transactions calling setData() on the oracle contract or periodically poll getData(key).

TypeScript Example

PriceTracker.ts

import { ethers } from 'ethers';

const ORACLE_POOL_ABI = [
    "function getOracle() view returns (address)",
    "function getTokenX() view returns (address)",
    "function getTokenY() view returns (address)",
    "function getReserves() view returns (uint256 reserveX, uint256 reserveY)",
    "event Swap(address indexed sender, address indexed recipient, bool indexed swapXtoY, uint256 amountIn, uint256 amountOut, uint256 feeIn)",
    "event Allocated(address indexed allocator, uint256 reserveX, uint256 reserveY)"
];

const CLCP_ORACLE_ABI = [
    "function getData(bytes32 key) view returns (uint256 price, uint256 feeHbps, uint256 alpha, uint256 expiry)",
    "function getCurrentPrice(bytes32 key, uint256 reserveX, uint256 reserveY) view returns (uint256 priceE24)"
];

const ERC20_ABI = [
    "function decimals() view returns (uint8)"
];

class PriceTracker {
    private pool: ethers.Contract;
    private oracle: ethers.Contract;
    private key: string;
    private decimalsX: number;
    private decimalsY: number;

    constructor(
        provider: ethers.Provider,
        poolAddress: string
    ) {
        this.pool = new ethers.Contract(poolAddress, ORACLE_POOL_ABI, provider);
    }

    async initialize() {
        // Get oracle and tokens
        const [oracleAddress, tokenX, tokenY] = await Promise.all([
            this.pool.getOracle(),
            this.pool.getTokenX(),
            this.pool.getTokenY()
        ]);

        this.oracle = new ethers.Contract(
            oracleAddress, 
            CLCP_ORACLE_ABI, 
            this.pool.runner
        );

        // Compute key
        this.key = ethers.solidityPackedKeccak256(
            ['address', 'address'],
            [tokenX, tokenY]
        );

        // Get decimals for price formatting (convert BigInt to number)
        const tokenXContract = new ethers.Contract(tokenX, ERC20_ABI, this.pool.runner);
        const tokenYContract = new ethers.Contract(tokenY, ERC20_ABI, this.pool.runner);
        
        const [decX, decY] = await Promise.all([
            tokenXContract.decimals(),
            tokenYContract.decimals()
        ]);
        this.decimalsX = Number(decX);
        this.decimalsY = Number(decY);

        console.log(`Initialized tracker for ${tokenX}/${tokenY}`);
        console.log(`Oracle key: ${this.key}`);
    }

    async getCurrentPrice(): Promise<{ priceE24: bigint; humanPrice: number }> {
        const { reserveX, reserveY }: { reserveX: bigint; reserveY: bigint } = 
            await this.pool.getReserves();
        const priceE24: bigint = await this.oracle.getCurrentPrice(this.key, reserveX, reserveY);
        
        // Convert to human-readable: priceE24 / 1e24 * 10^(decimalsX - decimalsY)
        // Use string conversion to avoid BigInt -> Number precision issues
        const decimalAdjustment = this.decimalsX - this.decimalsY;
        const humanPrice = parseFloat(priceE24.toString()) / 1e24 * Math.pow(10, decimalAdjustment);
        
        return { priceE24, humanPrice };
    }

    async getOracleData() {
        const [price, feeHbps, alpha, expiry]: [bigint, bigint, bigint, bigint] = 
            await this.oracle.getData(this.key);
        return {
            price,
            feeHbps,
            alpha,
            expiry,
            expiryDate: new Date(parseInt(expiry.toString()) * 1000)
        };
    }
}

// Usage
async function main() {
    const provider = new ethers.JsonRpcProvider("https://rpc3.monad.xyz");
    
    const tracker = new PriceTracker(provider, "0x...poolAddress");
    await tracker.initialize();
    
    // Get current price
    const { priceE24, humanPrice } = await tracker.getCurrentPrice();
    console.log(`Current price (1e24): ${priceE24}`);
    console.log(`Current price (human): ${humanPrice}`);
    
    // Get oracle data
    const oracleData = await tracker.getOracleData();
    console.log('Oracle data:', oracleData);
}

Python Example

price_tracker.py

from web3 import Web3
from eth_abi import encode

def compute_oracle_key(token_x: str, token_y: str) -> bytes:
    """Compute the oracle data key for a token pair."""
    packed = bytes.fromhex(token_x[2:]) + bytes.fromhex(token_y[2:])
    return Web3.keccak(packed)

def get_current_price(w3: Web3, pool_address: str) -> dict:
    """Get the current price from an OraclePool."""
    
    pool_abi = [
        {"name": "getOracle", "type": "function", "inputs": [], "outputs": [{"type": "address"}]},
        {"name": "getTokenX", "type": "function", "inputs": [], "outputs": [{"type": "address"}]},
        {"name": "getTokenY", "type": "function", "inputs": [], "outputs": [{"type": "address"}]},
        {"name": "getReserves", "type": "function", "inputs": [], "outputs": [{"type": "uint256"}, {"type": "uint256"}]},
    ]
    
    oracle_abi = [
        {"name": "getData", "type": "function", "inputs": [{"type": "bytes32"}], 
         "outputs": [{"type": "uint256"}, {"type": "uint256"}, {"type": "uint256"}, {"type": "uint256"}]},
        {"name": "getCurrentPrice", "type": "function", "inputs": [{"type": "bytes32"}, {"type": "uint256"}, {"type": "uint256"}], 
         "outputs": [{"type": "uint256"}]},
    ]
    
    pool = w3.eth.contract(address=pool_address, abi=pool_abi)
    
    # Get pool info
    oracle_address = pool.functions.getOracle().call()
    token_x = pool.functions.getTokenX().call()
    token_y = pool.functions.getTokenY().call()
    reserve_x, reserve_y = pool.functions.getReserves().call()
    
    # Compute key and get price
    oracle = w3.eth.contract(address=oracle_address, abi=oracle_abi)
    key = compute_oracle_key(token_x, token_y)
    
    price_e24 = oracle.functions.getCurrentPrice(key, reserve_x, reserve_y).call()
    oracle_data = oracle.functions.getData(key).call()
    
    return {
        "token_x": token_x,
        "token_y": token_y,
        "reserve_x": reserve_x,
        "reserve_y": reserve_y,
        "price_e24": price_e24,
        "oracle_price": oracle_data[0],
        "fee_hbps": oracle_data[1],
        "alpha": oracle_data[2],
        "expiry": oracle_data[3],
    }

# Usage
if __name__ == "__main__":
    w3 = Web3(Web3.HTTPProvider("https://rpc3.monad.xyz"))
    
    result = get_current_price(w3, "0x...poolAddress")
    
    print(f"Token X: {result['token_x']}")
    print(f"Token Y: {result['token_y']}")
    print(f"Reserves: {result['reserve_x']} / {result['reserve_y']}")
    print(f"Current Price (1e24): {result['price_e24']}")
    print(f"Oracle Price (1e24): {result['oracle_price']}")
    print(f"Alpha: {result['alpha']} BPS")

Key Takeaways

1

Price is a function of oracle data and reserves

You need both to get the actual price.

2

Oracle data has no events

You must poll getData(key) or watch transactions that call setData().

3

Reserve changes have events

Watch Swap and Allocated events for reserve-driven price changes.

4

Price precision is 1e24

Use humanPrice = priceE24 / 1e24 * 10^(decimalsX - decimalsY)

5

Alpha defines the allowed range

Actual price is bounded by [P/alpha, P*alpha].