@symmetry-hq/sdk 1.0.1

package/src/states/oracles/raydiumClmmOracle.ts

@@ -0,0 +1,1193 @@
+import Decimal from 'decimal.js';
+
+import BN from 'bn.js';
+import { AccountInfo, PublicKey } from '@solana/web3.js';
+
+import { HUNDRED_PERCENT_BPS } from '../../constants';
+import { OracleSettings, Quote, Side } from '../../layouts/oracle';
+import { U128_MAX } from './constants';
+import { OraclePrice } from './oracle';
+
+const CLMM_PROGRAM_ID = new PublicKey("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK");
+const TICK_ARRAY_SEED = Buffer.from("tick_array");
+const MIN_TICK = -443636;
+const MAX_TICK = 443636;
+
+export function i32ToBytes(num: number): Uint8Array {
+    const arr = new ArrayBuffer(4);
+    const view = new DataView(arr);
+    view.setInt32(0, num, false);
+    return new Uint8Array(arr);
+}
+export function getTickArrayStartIndexByTick(tickIndex: number, tickSpacing: number): number {
+    const perArray = TICK_ARRAY_SIZE_USIZE * tickSpacing;
+    return Math.floor(tickIndex / perArray) * perArray;
+}
+export function getNextTickArrayStartIndex(lastStart: number, tickSpacing: number, zeroForOne: boolean): number {
+    return zeroForOne ? lastStart - tickSpacing * TICK_ARRAY_SIZE_USIZE : lastStart + tickSpacing * TICK_ARRAY_SIZE_USIZE;
+}
+export function getPdaTickArrayAddress(poolId: PublicKey, startIndex: number): PublicKey {
+    return PublicKey.findProgramAddressSync(
+        [TICK_ARRAY_SEED, poolId.toBuffer(), i32ToBytes(startIndex)],
+        CLMM_PROGRAM_ID
+    )[0];
+}
+
+
+class Observation {
+    blockTimestamp: BN;
+    tickCumulative: BN;
+    padding: BN[];
+    constructor(params: {blockTimestamp: BN, tickCumulative: BN, padding: BN[]}){
+        this.blockTimestamp = params.blockTimestamp;
+        this.tickCumulative = params.tickCumulative;
+        this.padding = params.padding;
+    }
+    static decode(data: Buffer, offset = 0): [Observation, number] {
+        
+        const blockTimestamp = new BN(data.readUInt32LE(offset));
+
+        const tickCumulative = new BN(
+            data.subarray(offset + 4, offset + 12),
+            "le"
+        ).fromTwos(64);
+
+        const padding: BN[] = [];
+        let cursor = offset + 12;
+        for (let i = 0; i < 4; i++) {
+            padding.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        return [
+            new Observation({ 
+                blockTimestamp, 
+                tickCumulative, 
+                padding }),
+            cursor
+        ];
+    }
+
+
+
+    sub(other: Observation): Observation {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Subtraction is only supported between Observation instances");
+        }
+
+        return new Observation({
+            blockTimestamp: this.blockTimestamp.sub(other.blockTimestamp),
+            tickCumulative: this.tickCumulative.sub(other.tickCumulative),
+            padding: this.padding
+        });
+    }
+
+    add(other: Observation): Observation {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Addition is only supported between Observation instances");
+        }
+        return new Observation({
+            blockTimestamp: this.blockTimestamp.add(other.blockTimestamp),
+            tickCumulative: this.tickCumulative.add(other.tickCumulative),
+            padding: this.padding
+        });
+    }
+
+    getWeightedObservation(time: BN): Observation {
+        // cumT = (self.tickCumulative * time) / self.blockTimestamp
+        const cum = this.tickCumulative.mul(time).div(this.blockTimestamp);
+        return new Observation({
+            blockTimestamp: time,
+            tickCumulative: cum,
+            padding: this.padding
+        });
+    }
+
+    adjustToTimestamp(targetTimestamp: BN, observationPrev: Observation): Observation {
+        // delta = self.sub(prevObservation)
+        const delta = this.sub(observationPrev);
+
+        // weightedDelta = delta.getWeightedObservation(targetTimestamp - self.blockTimestamp)
+        const timeForWeighted = targetTimestamp.sub(this.blockTimestamp);
+        const weightedDelta = delta.getWeightedObservation(timeForWeighted);
+
+        // return self.add(weightedDelta)
+        return this.add(weightedDelta);
+    }
+
+}
+
+class ObservationState {
+    initialized: boolean;
+    recentEpoch: BN;
+    observationIndex: number;
+    poolId: PublicKey;
+    observations: Observation[];
+    padding: BN[];
+
+    constructor(params: {
+        initialized: boolean,
+        recentEpoch: BN,
+        observationIndex: number,
+        poolId: PublicKey,
+        observations: Observation[],
+        padding: BN[]
+    }){
+        this.initialized = params.initialized;
+        this.recentEpoch = params.recentEpoch;
+        this.observationIndex = params.observationIndex;
+        this.poolId = params.poolId;
+        this.observations = params.observations;
+        this.padding = params.padding;
+    }
+
+    static decode(data: Buffer, offset = 8): [ObservationState, number] {
+        let cursor = offset;
+
+        const initialized = data.readUInt8(cursor) !== 0;
+        cursor += 1;
+
+        const recentEpoch = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const observationIndex = data.readUInt16LE(cursor);
+        cursor += 2;
+
+        const poolId = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const observations: Observation[] = [];
+        for (let i = 0; i < 100; i++) {
+            let obs: Observation;
+            [obs, cursor] = Observation.decode(data, cursor);
+            observations.push(obs);
+        }
+
+        const padding: BN[] = [];
+        for (let i = 0; i < 4; i++) {
+            padding.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        return [
+            new ObservationState({ initialized, recentEpoch, observationIndex, poolId, observations, padding }),
+            cursor
+        ];
+        }
+
+}
+
+class RewardInfo {
+    rewardState: number;
+    openTime: BN;
+    endTime: BN;
+    lastUpdateTime: BN;
+    emissionsPerSecondX64: BN;
+    rewardTotalEmissioned: BN;
+    rewardClaimed: BN;
+    tokenMint: PublicKey;
+    tokenVault: PublicKey;
+    authority: PublicKey;
+    rewardGrowthGlobalX64: BN;
+
+    constructor(params: {
+        rewardState: number,
+        openTime: BN,
+        endTime: BN,
+        lastUpdateTime: BN,
+        emissionsPerSecondX64: BN,
+        rewardTotalEmissioned: BN,
+        rewardClaimed: BN,
+        tokenMint: PublicKey,
+        tokenVault: PublicKey,
+        authority: PublicKey,
+        rewardGrowthGlobalX64: BN
+    }){
+        this.rewardState = params.rewardState;
+        this.openTime = params.openTime;
+        this.endTime = params.endTime;
+        this.lastUpdateTime = params.lastUpdateTime;
+        this.emissionsPerSecondX64 = params.emissionsPerSecondX64;
+        this.rewardTotalEmissioned = params.rewardTotalEmissioned;
+        this.rewardClaimed = params.rewardClaimed;
+        this.tokenMint = params.tokenMint;
+        this.tokenVault = params.tokenVault;
+        this.authority = params.authority;
+        this.rewardGrowthGlobalX64 = params.rewardGrowthGlobalX64;
+    }
+
+    static decode(data: Buffer, offset: number = 0): [RewardInfo, number] {
+        let cursor = offset;
+
+        const rewardState = data.readUInt8(cursor);
+        cursor += 1;
+
+        const openTime = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const endTime = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const lastUpdateTime = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const emissionsPerSecondX64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const rewardTotalEmissioned = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const rewardClaimed = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const tokenMint = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const tokenVault = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const authority = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const rewardGrowthGlobalX64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        
+        return [ new RewardInfo({
+            rewardState,
+            openTime,
+            endTime,
+            lastUpdateTime,
+            emissionsPerSecondX64,
+            rewardTotalEmissioned,
+            rewardClaimed,
+            tokenMint,
+            tokenVault,
+            authority,
+            rewardGrowthGlobalX64
+        }), cursor]; 
+
+    }
+}
+
+
+
+export class PoolState {
+    bump: number[];
+    ammConfig: PublicKey;
+    owner: PublicKey;
+    tokenMint0: PublicKey;
+    tokenMint1: PublicKey;
+    tokenVault0: PublicKey;
+    tokenVault1: PublicKey;
+    observationKey: PublicKey;
+    mintDecimals0: number;
+    mintDecimals1: number;
+    tickSpacing: number;
+    liquidity: BN;
+    sqrtPriceX64: BN;
+    tickCurrent: number;
+    padding3: number;
+    padding4: number;
+    feeGrowthGlobal0X64: BN;
+    feeGrowthGlobal1X64: BN;
+    protocolFeesToken0: BN;
+    protocolFeesToken1: BN;
+    swapInAmountToken0: BN;
+    swapOutAmountToken1: BN;
+    swapInAmountToken1: BN;
+    swapOutAmountToken0: BN;
+    status: number;
+    padding: number[];
+    rewardInfos: RewardInfo[];
+    tickArrayBitmap: BN[];
+    totalFeesToken0: BN;
+    totalFeesClaimedToken0: BN;
+    totalFeesToken1: BN;
+    totalFeesClaimedToken1: BN;
+    fundFeesToken0: BN;
+    fundFeesToken1: BN;
+    openTime: BN;
+    recentEpoch: BN;
+    padding1: BN[];
+    padding2: BN[];
+
+    constructor(
+        params: {
+            bump: number[],
+            ammConfig: PublicKey,
+            owner: PublicKey,
+            tokenMint0: PublicKey,
+            tokenMint1: PublicKey,
+            tokenVault0: PublicKey,
+            tokenVault1: PublicKey,
+            observationKey: PublicKey,
+            mintDecimals0: number,
+            mintDecimals1: number,
+            tickSpacing: number,
+            liquidity: BN,
+            sqrtPriceX64: BN,
+            tickCurrent: number,
+            padding3: number,
+            padding4: number,
+            feeGrowthGlobal0X64: BN,
+            feeGrowthGlobal1X64: BN,
+            protocolFeesToken0: BN,
+            protocolFeesToken1: BN,
+            swapInAmountToken0: BN,
+            swapOutAmountToken1: BN,
+            swapInAmountToken1: BN,
+            swapOutAmountToken0: BN,
+            status: number,
+            padding: number[],
+            rewardInfos: RewardInfo[],
+            tickArrayBitmap: BN[],
+            totalFeesToken0: BN,
+            totalFeesClaimedToken0: BN,
+            totalFeesToken1: BN,
+            totalFeesClaimedToken1: BN,
+            fundFeesToken0: BN,
+            fundFeesToken1: BN,
+            openTime: BN,
+            recentEpoch: BN,
+            padding1: BN[],
+            padding2: BN[]
+        }
+    ){
+        this.bump = params.bump;
+        this.ammConfig = params.ammConfig;
+        this.owner = params.owner;
+        this.tokenMint0 = params.tokenMint0;
+        this.tokenMint1 = params.tokenMint1;
+        this.tokenVault0 = params.tokenVault0;
+        this.tokenVault1 = params.tokenVault1;
+        this.observationKey = params.observationKey;
+        this.mintDecimals0 = params.mintDecimals0;
+        this.mintDecimals1 = params.mintDecimals1;
+        this.tickSpacing = params.tickSpacing;
+        this.liquidity = params.liquidity;
+        this.sqrtPriceX64 = params.sqrtPriceX64;
+        this.tickCurrent = params.tickCurrent;
+        this.padding3 = params.padding3;
+        this.padding4 = params.padding4;
+        this.feeGrowthGlobal0X64 = params.feeGrowthGlobal0X64;
+        this.feeGrowthGlobal1X64 = params.feeGrowthGlobal1X64;
+        this.protocolFeesToken0 = params.protocolFeesToken0;
+        this.protocolFeesToken1 = params.protocolFeesToken1;
+        this.swapInAmountToken0 = params.swapInAmountToken0;
+        this.swapOutAmountToken1 = params.swapOutAmountToken1;
+        this.swapInAmountToken1 = params.swapInAmountToken1;
+        this.swapOutAmountToken0 = params.swapOutAmountToken0;
+        this.status = params.status;
+        this.padding = params.padding;
+        this.rewardInfos = params.rewardInfos;
+        this.tickArrayBitmap = params.tickArrayBitmap;
+        this.totalFeesToken0 = params.totalFeesToken0;
+        this.totalFeesClaimedToken0 = params.totalFeesClaimedToken0;
+        this.totalFeesToken1 = params.totalFeesToken1;
+        this.totalFeesClaimedToken1 = params.totalFeesClaimedToken1;
+        this.fundFeesToken0 = params.fundFeesToken0;
+        this.fundFeesToken1 = params.fundFeesToken1;
+        this.openTime = params.openTime;
+        this.recentEpoch = params.recentEpoch;
+        this.padding1 = params.padding1;
+        this.padding2 = params.padding2; 
+    }
+
+    static decode(data: Buffer, offset: number = 8): [PoolState, number] {
+        let cursor = offset;
+
+        const bump = [data.readUInt8(cursor)];
+        cursor += 1;
+
+        const ammConfig = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const owner = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const tokenMint0 = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const tokenMint1 = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const tokenVault0 = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const tokenVault1 = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const observationKey = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const mintDecimals0 = data.readUInt8(cursor);
+        cursor += 1;
+
+        const mintDecimals1 = data.readUInt8(cursor);
+        cursor += 1;
+
+        const tickSpacing = data.readUInt16LE(cursor);
+        cursor += 2;
+
+        const liquidity = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const sqrtPriceX64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const tickCurrent = data.readInt32LE(cursor);
+        cursor += 4;
+
+        const padding3 = data.readUInt16LE(cursor);
+        cursor += 2;
+
+        const padding4 = data.readUInt16LE(cursor);
+        cursor += 2;
+
+        const feeGrowthGlobal0X64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const feeGrowthGlobal1X64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const protocolFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const protocolFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const swapInAmountToken0 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const swapOutAmountToken1 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const swapInAmountToken1 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const swapOutAmountToken0 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const status = data.readUInt8(cursor);
+        cursor += 1;
+
+        const padding: number[] = [];
+        for (let i = 0; i < 7; i++) {
+            padding.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+
+        // RewardInfos
+        const rewardInfos: RewardInfo[] = [];
+        for (let i = 0; i < 3; i++) {
+            const decoded = RewardInfo.decode(data, cursor);
+            rewardInfos.push(decoded[0]);
+            cursor = decoded[1];
+        }
+
+        // tickArrayBitmap [u64;16]
+        const tickArrayBitmap: BN[] = [];
+        for (let i = 0; i < 16; i++) {
+            tickArrayBitmap.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        const totalFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const totalFeesClaimedToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const totalFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const totalFeesClaimedToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const fundFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const fundFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const openTime = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const recentEpoch = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const padding1: BN[] = [];
+        for (let i = 0; i < 24; i++) {
+            padding1.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        const padding2: BN[] = [];
+        for (let i = 0; i < 32; i++) {
+            padding2.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        return [
+            new PoolState({
+            bump,
+            ammConfig,
+            owner,
+            tokenMint0,
+            tokenMint1,
+            tokenVault0,
+            tokenVault1,
+            observationKey,
+            mintDecimals0,
+            mintDecimals1,
+            tickSpacing,
+            liquidity,
+            sqrtPriceX64,
+            tickCurrent,
+            padding3,
+            padding4,
+            feeGrowthGlobal0X64,
+            feeGrowthGlobal1X64,
+            protocolFeesToken0,
+            protocolFeesToken1,
+            swapInAmountToken0,
+            swapOutAmountToken1,
+            swapInAmountToken1,
+            swapOutAmountToken0,
+            status,
+            padding,
+            rewardInfos,
+            tickArrayBitmap,
+            totalFeesToken0,
+            totalFeesClaimedToken0,
+            totalFeesToken1,
+            totalFeesClaimedToken1,
+            fundFeesToken0,
+            fundFeesToken1,
+            openTime,
+            recentEpoch,
+            padding1,
+            padding2,
+            }),
+            cursor,
+        ];
+    }
+
+
+}
+
+const TICK_ARRAY_SIZE_USIZE = 60;
+const REWARD_NUM = 3;
+
+class TickState {
+    tick: number; // i32
+    liquidityNet: BN; // i128 (signed)
+    liquidityGross: BN; // u128
+    feeGrowthOutside0X64: BN; // u128
+    feeGrowthOutside1X64: BN; // u128
+    rewardGrowthsOutsideX64: BN[]; // [u128; REWARD_NUM]
+    padding: number[]; // [u32;13]
+
+    constructor(params: {
+        tick: number,
+        liquidityNet: BN,
+        liquidityGross: BN,
+        feeGrowthOutside0X64: BN,
+        feeGrowthOutside1X64: BN,
+        rewardGrowthsOutsideX64: BN[],
+        padding: number[]
+    }){
+        this.tick = params.tick;
+        this.liquidityNet = params.liquidityNet;
+        this.liquidityGross = params.liquidityGross;
+        this.feeGrowthOutside0X64 = params.feeGrowthOutside0X64;
+        this.feeGrowthOutside1X64 = params.feeGrowthOutside1X64;
+        this.rewardGrowthsOutsideX64 = params.rewardGrowthsOutsideX64;
+        this.padding = params.padding;
+    }
+
+    static decode(data: Buffer, offset: number = 0): [TickState, number] {
+        let cursor = offset;
+
+        const tick = data.readInt32LE(cursor);
+        cursor += 4;
+
+        // liquidity_net: i128 (signed)
+        const liquidityNet = new BN(data.subarray(cursor, cursor + 16), "le").fromTwos(128);
+        cursor += 16;
+
+        // liquidity_gross: u128
+        const liquidityGross = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const feeGrowthOutside0X64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const feeGrowthOutside1X64 = new BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+
+        const rewardGrowthsOutsideX64: BN[] = [];
+        for (let i = 0; i < REWARD_NUM; i++) {
+            rewardGrowthsOutsideX64.push(new BN(data.subarray(cursor, cursor + 16), "le"));
+            cursor += 16;
+        }
+
+        const padding: number[] = [];
+        for (let i = 0; i < 13; i++) {
+            padding.push(data.readUInt32LE(cursor));
+            cursor += 4;
+        }
+
+        return [
+            new TickState({
+                tick,
+                liquidityNet,
+                liquidityGross,
+                feeGrowthOutside0X64,
+                feeGrowthOutside1X64,
+                rewardGrowthsOutsideX64,
+                padding
+            }),
+            cursor
+        ];
+    }
+}
+
+class TickArrayState {
+    poolId: PublicKey;
+    startTickIndex: number; // i32
+    ticks: TickState[]; // length TICK_ARRAY_SIZE_USIZE
+    initializedTickCount: number; // u8
+    recentEpoch: BN; // u64
+    padding: number[]; // u8[107]
+
+    constructor(params: {
+        poolId: PublicKey,
+        startTickIndex: number,
+        ticks: TickState[],
+        initializedTickCount: number,
+        recentEpoch: BN,
+        padding: number[]
+    }){
+        this.poolId = params.poolId;
+        this.startTickIndex = params.startTickIndex;
+        this.ticks = params.ticks;
+        this.initializedTickCount = params.initializedTickCount;
+        this.recentEpoch = params.recentEpoch;
+        this.padding = params.padding;
+    }
+
+    static decode(data: Buffer, offset: number = 8): [TickArrayState, number] {
+        let cursor = offset;
+
+        const poolId = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const startTickIndex = data.readInt32LE(cursor);
+        cursor += 4;
+
+        const ticks: TickState[] = [];
+        for (let i = 0; i < TICK_ARRAY_SIZE_USIZE; i++) {
+            const [tickState, next] = TickState.decode(data, cursor);
+            ticks.push(tickState);
+            cursor = next;
+        }
+
+        const initializedTickCount = data.readUInt8(cursor);
+        cursor += 1;
+
+        const recentEpoch = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const padding: number[] = [];
+        for (let i = 0; i < 107; i++) {
+            padding.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+
+        return [
+            new TickArrayState({
+                poolId,
+                startTickIndex,
+                ticks,
+                initializedTickCount,
+                recentEpoch,
+                padding
+            }),
+            cursor
+        ];
+    }
+}
+
+
+
+export class RaydiumCLMMOracle {
+
+
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number] {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return PublicKey.findProgramAddressSync(seeds, CLMM_PROGRAM_ID);
+    };
+
+    static getObservationAtIndex(observations: Observation[], index: number) {
+        return observations[index];
+    }
+
+    static getObservationAtTimestamp(timestamp: BN, observations: Observation[], startIndex: number): Observation {
+        let observationCurrent = this.getObservationAtIndex(observations, startIndex);
+        let index = startIndex;
+
+        // const obsIndex = this.observationState.observationIndex;
+
+        // Loop backwards until we find the observation <= timestamp
+        while (observationCurrent.blockTimestamp.gt(timestamp)) {
+            index = (index - 1 + 100) % 100;
+            observationCurrent = this.getObservationAtIndex(observations, index);
+
+            if (index === startIndex) {
+                throw Error("Observations do not go back far enough in time");
+                break; // looped all the way around
+            }
+        }
+
+        // Previous index for interpolation
+        const prevIndex = (index - 1 + 100) % 100;
+        const observationPrev = this.getObservationAtIndex(observations, prevIndex);
+
+        // Adjust current observation to the target timestamp
+        const result = observationCurrent.adjustToTimestamp(timestamp, observationPrev);
+        return result;
+    }
+
+    static getDeltaObservations(currentTime: BN, observations: Observation[], observationIndex: number, primarySeconds: BN, secondarySeconds: BN): Observation[] {
+
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, observations, observationIndex);
+
+        const observationPrimary = this.getObservationAtTimestamp(new BN(currentTime.sub(primarySeconds)), observations, observationIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+
+        const observationSecondary = this.getObservationAtTimestamp(new BN(currentTime.sub(secondarySeconds)), observations, observationIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+
+        return [deltaPrimary,deltaSecondary];
+    }
+
+
+    static getSqrtPriceX64FromTick(tick: number): BN {
+
+        if (!Number.isInteger(tick)) {
+        throw new Error("tick must be integer");
+        }
+        if (tick < MIN_TICK || tick > MAX_TICK) {
+        throw new Error("tick must be in MIN_TICK and MAX_TICK");
+        }
+        const tickAbs: number = tick < 0 ? tick * -1 : tick;
+
+        let ratio: BN = (tickAbs & 0x1) != 0 ? new BN("18445821805675395072") : new BN("18446744073709551616");
+        if ((tickAbs & 0x2) != 0) ratio = mulRightShift(ratio, new BN("18444899583751176192"));
+        if ((tickAbs & 0x4) != 0) ratio = mulRightShift(ratio, new BN("18443055278223355904"));
+        if ((tickAbs & 0x8) != 0) ratio = mulRightShift(ratio, new BN("18439367220385607680"));
+        if ((tickAbs & 0x10) != 0) ratio = mulRightShift(ratio, new BN("18431993317065453568"));
+        if ((tickAbs & 0x20) != 0) ratio = mulRightShift(ratio, new BN("18417254355718170624"));
+        if ((tickAbs & 0x40) != 0) ratio = mulRightShift(ratio, new BN("18387811781193609216"));
+        if ((tickAbs & 0x80) != 0) ratio = mulRightShift(ratio, new BN("18329067761203558400"));
+        if ((tickAbs & 0x100) != 0) ratio = mulRightShift(ratio, new BN("18212142134806163456"));
+        if ((tickAbs & 0x200) != 0) ratio = mulRightShift(ratio, new BN("17980523815641700352"));
+        if ((tickAbs & 0x400) != 0) ratio = mulRightShift(ratio, new BN("17526086738831433728"));
+        if ((tickAbs & 0x800) != 0) ratio = mulRightShift(ratio, new BN("16651378430235570176"));
+        if ((tickAbs & 0x1000) != 0) ratio = mulRightShift(ratio, new BN("15030750278694412288"));
+        if ((tickAbs & 0x2000) != 0) ratio = mulRightShift(ratio, new BN("12247334978884435968"));
+        if ((tickAbs & 0x4000) != 0) ratio = mulRightShift(ratio, new BN("8131365268886854656"));
+        if ((tickAbs & 0x8000) != 0) ratio = mulRightShift(ratio, new BN("3584323654725218816"));
+        if ((tickAbs & 0x10000) != 0) ratio = mulRightShift(ratio, new BN("696457651848324352"));
+        if ((tickAbs & 0x20000) != 0) ratio = mulRightShift(ratio, new BN("26294789957507116"));
+        if ((tickAbs & 0x40000) != 0) ratio = mulRightShift(ratio, new BN("37481735321082"));
+
+        if (tick > 0) ratio = U128_MAX.div(ratio);
+        return ratio;
+    }
+
+    static sqrtPriceX64ToPrice(sqrtPriceX64: BN, decimalsA: number, decimalsB: number): Decimal {
+
+        return this.x64ToDecimal(sqrtPriceX64)
+                        .pow(2)
+                        .mul(Decimal.pow(10, decimalsA - decimalsB));
+    }
+
+    static x64ToDecimal(num: BN, decimalPlaces?: number): Decimal {
+
+        return new Decimal(num.toString()).div(Decimal.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+    }
+
+    static getSpotPrice(tickCurrent: number, mintDecimals0: number, mintDecimals1: number): Decimal {
+        let price = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tickCurrent),
+                                                mintDecimals0,
+                                                mintDecimals1);
+        return price;
+    }
+
+    static getTwapPrimary(
+        observations: Observation[], observationIndex: number, primarySeconds: BN, secondarySeconds: BN, 
+        mintDecimals0: number, mintDecimals1: number, currentTime: BN): Decimal {
+
+        let observation = this.getDeltaObservations(currentTime, observations, observationIndex, primarySeconds, secondarySeconds)[0];
+
+        let tick = observation.tickCumulative.div(observation.blockTimestamp).toNumber();
+        let twap = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tick),
+                                                mintDecimals0,
+                                                mintDecimals1);
+        return twap;
+    }
+
+    static getTwapSecondary(
+        observations: Observation[], observationIndex: number, primarySeconds: BN, secondarySeconds: BN, 
+        mintDecimals0: number, mintDecimals1: number, currentTime: BN): Decimal {
+
+        let observation = this.getDeltaObservations(currentTime, observations, observationIndex, primarySeconds, secondarySeconds)[1];
+        let tick = observation.tickCumulative.div(observation.blockTimestamp).toNumber();
+        let twap = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tick),
+                                                mintDecimals0,
+                                                mintDecimals1);
+        return twap;
+    }
+
+    static getConfidence(
+        observations: Observation[], observationIndex: number,
+        primarySeconds: BN, secondarySeconds: BN, tickCurrent: number, 
+        mintDecimals0: number, mintDecimals1: number, currentTime: BN
+    ): Decimal {
+
+        let primary = this.getTwapPrimary(
+            observations, observationIndex, primarySeconds, secondarySeconds,
+            mintDecimals0, mintDecimals1, currentTime);
+        let secondary = this.getTwapSecondary(
+            observations, observationIndex, primarySeconds, secondarySeconds,
+            mintDecimals0, mintDecimals1, currentTime);
+        let spot = this.getSpotPrice(tickCurrent, mintDecimals0, mintDecimals1);
+
+        let first = primary.sub(spot).abs();
+        let second = secondary.sub(spot).abs();
+        let third = primary.sub(secondary).abs();
+
+        let conf = Decimal.max(first, second, third);
+
+        return conf;
+    }
+
+     static calculateMaxPriceImpactForMinLiquidity(
+        oracleParams: OracleSettings,
+        poolState: PoolState,
+        prevTickArray: TickArrayState,
+        currentTickArray: TickArrayState,
+        nextTickArray: TickArrayState,
+        solPrice: OraclePrice,
+        usdPrice: OraclePrice,
+    ): Decimal {
+        // local helpers / aliases
+        const sStart = this.x64ToDecimal(poolState.sqrtPriceX64);
+        const Lstart = new Decimal(poolState.liquidity.toString());
+        const spotPrice = this.sqrtPriceX64ToPrice(poolState.sqrtPriceX64, poolState.mintDecimals0, poolState.mintDecimals1);
+        const minLiquidityUsd = new Decimal(oracleParams.minLiquidity.toString());
+        let amountQuote: Decimal;
+        if (oracleParams.quote === Quote.Usdc) {
+            amountQuote = minLiquidityUsd.mul(new Decimal(10).pow(6)).div(usdPrice.price);
+        } else {
+            amountQuote = minLiquidityUsd.mul(new Decimal(10).pow(9)).div(solPrice.price);
+        }
+        const tickSpacing = poolState.tickSpacing;
+
+        // Build fast lookup structures once:
+        // - tickMap: absoluteTick -> TickState
+        // - arrays of initialized tick indices per region (prev/current/next)
+        const tickMap = new Map<number, TickState>();
+        const prevIdxs: number[] = [];
+        const currIdxs: number[] = [];
+        const nextIdxs: number[] = [];
+
+        const pushTicks = (ta: TickArrayState, outArr: number[]) => {
+            const start = ta.startTickIndex;
+            for (let i = 0; i < ta.ticks.length; i++) {
+                const tickVal = start + i * tickSpacing;
+                const t = ta.ticks[i];
+                // store in map regardless, to speed up findTickState
+                tickMap.set(tickVal, t);
+                if (t.liquidityGross.gt(new BN(0))) outArr.push(tickVal);
+            }
+        };
+
+        pushTicks(prevTickArray, prevIdxs);
+        pushTicks(currentTickArray, currIdxs);
+        pushTicks(nextTickArray, nextIdxs);
+
+        // findTickState map lookup
+        const findTickState = (idx: number | null): TickState | null => {
+            if (idx === null) return null;
+            return tickMap.get(idx) ?? null;
+        };
+
+        // find next initialized tick index scanning only relevant arrays:
+        // forward === true => check current then next
+        // forward === false => check current then prev
+        const findNextInitializedTickIndex = (startTick: number, forward: boolean): number | null => {
+            const lists = forward ? [currIdxs, nextIdxs] : [currIdxs, prevIdxs];
+            let best: number | null = null;
+            for (const list of lists) {
+                // for forward: find smallest tick > startTick
+                // for backward: find largest tick < startTick
+                if (forward) {
+                    for (let i = 0; i < list.length; i++) {
+                        const v = list[i];
+                        if (v > startTick) {
+                            best = best === null ? v : Math.min(best, v);
+                            // since list ascending we can break early for this list
+                            break;
+                        }
+                    }
+                    if (best !== null) break; // we already found closest in current list
+                } else {
+                    // backward: list ascending, scan from end for speed
+                    for (let i = list.length - 1; i >= 0; i--) {
+                        const v = list[i];
+                        if (v < startTick) {
+                            best = best === null ? v : Math.max(best, v);
+                            break;
+                        }
+                    }
+                    if (best !== null) break;
+                }
+            }
+            return best;
+        };
+
+        const sFor = (tickIdx: number | null) =>
+            tickIdx === null ? null : this.x64ToDecimal(this.getSqrtPriceX64FromTick(tickIdx));
+
+        // simulate quote -> base (s increases). returns avg quote-per-base or null
+        const simulateIncrease = (amountQ: Decimal): Decimal | null => {
+            let remaining = amountQ;
+            let s = sStart;
+            let L = Lstart;
+            let totalBaseOut = new Decimal(0);
+            let currentTick = poolState.tickCurrent;
+            let boundary = findNextInitializedTickIndex(currentTick, true);
+
+            let steps = 0;
+            while (remaining.gt(0) && steps++ < 500) {
+                const sBoundary = sFor(boundary);
+                if (!sBoundary) {
+                    // no known boundary -> consume all in one segment
+                    const sEnd = s.add(remaining.div(L));
+                    totalBaseOut = totalBaseOut.add(L.mul(new Decimal(1).div(s).sub(new Decimal(1).div(sEnd))));
+                    remaining = new Decimal(0);
+                    break;
+                }
+
+                const deltaQToBoundary = L.mul(sBoundary.sub(s));
+                if (remaining.lte(deltaQToBoundary)) {
+                    const sEnd = s.add(remaining.div(L));
+                    totalBaseOut = totalBaseOut.add(L.mul(new Decimal(1).div(s).sub(new Decimal(1).div(sEnd))));
+                    remaining = new Decimal(0);
+                    break;
+                }
+
+                // consume whole segment to boundary
+                totalBaseOut = totalBaseOut.add(L.mul(new Decimal(1).div(s).sub(new Decimal(1).div(sBoundary))));
+                remaining = remaining.sub(deltaQToBoundary);
+
+                // cross tick: safe to assert boundary non-null because sBoundary existed
+                const bt = boundary!;
+                const ts = findTickState(bt);
+                if (ts) L = L.add(new Decimal(ts.liquidityNet.toString()));
+                s = sBoundary;
+                currentTick = bt + tickSpacing;
+                boundary = findNextInitializedTickIndex(currentTick, true);
+            }
+
+            if (totalBaseOut.lte(0)) return null;
+            return amountQ.div(totalBaseOut);
+        };
+
+        // simulate base -> quote (s decreases). amountQuote is converted to approximate amountBase via spot
+        const simulateDecrease = (amountQ: Decimal): Decimal | null => {
+            const amountBase = amountQ.div(spotPrice);
+            let remainingBase = amountBase;
+            let s = sStart;
+            let L = Lstart;
+            let totalQuoteOut = new Decimal(0);
+            let currentTick = poolState.tickCurrent;
+            let boundary = findNextInitializedTickIndex(currentTick, false);
+
+            let steps = 0;
+            while (remainingBase.gt(0) && steps++ < 500) {
+                const sBoundary = sFor(boundary);
+                if (!sBoundary) {
+                    const denom = L.add(remainingBase.mul(s));
+                    if (denom.eq(0)) return null;
+                    const sEnd = L.mul(s).div(denom);
+                    totalQuoteOut = totalQuoteOut.add(L.mul(s.sub(sEnd)));
+                    remainingBase = new Decimal(0);
+                    break;
+                }
+
+                const deltaAtoBoundary = L.mul(new Decimal(1).div(sBoundary).sub(new Decimal(1).div(s)));
+                if (remainingBase.lte(deltaAtoBoundary)) {
+                    const denom = L.add(remainingBase.mul(s));
+                    const sEnd = L.mul(s).div(denom);
+                    totalQuoteOut = totalQuoteOut.add(L.mul(s.sub(sEnd)));
+                    remainingBase = new Decimal(0);
+                    break;
+                }
+
+                // consume to boundary
+                const denom = L.add(deltaAtoBoundary.mul(s));
+                const sEnd = L.mul(s).div(denom);
+                totalQuoteOut = totalQuoteOut.add(L.mul(s.sub(sEnd)));
+                remainingBase = remainingBase.sub(deltaAtoBoundary);
+
+                // cross tick going down
+                const bt = boundary!;
+                const ts = findTickState(bt);
+                if (ts) L = L.sub(new Decimal(ts.liquidityNet.toString()));
+                s = sEnd;
+                currentTick = bt - tickSpacing;
+                boundary = findNextInitializedTickIndex(currentTick, false);
+            }
+
+            if (totalQuoteOut.lte(0)) return null;
+            if (amountBase.eq(0)) return null;
+            return totalQuoteOut.div(amountBase);
+        };
+
+        const up = simulateIncrease(amountQuote);
+        const down = simulateDecrease(amountQuote);
+
+        const toImpact = (avg: Decimal | null) =>
+            !avg || avg.lte(0) ? new Decimal(0) : avg.sub(spotPrice).abs().div(spotPrice).mul(new Decimal(10000));
+
+        return Decimal.max(toImpact(up), toImpact(down));
+    }
+
+
+    
+    static fetch(
+        oracleParams: OracleSettings,
+        accountInfos: AccountInfo<Buffer>[],
+        solPrice: OraclePrice,
+        usdPrice: OraclePrice,
+    ): OraclePrice {
+
+        const poolState = accountInfos[0];
+        const observationState = accountInfos[1];
+        const prevTickArrayState = accountInfos[2];
+        const currentTickArrayState = accountInfos[3];
+        const nextTickArrayState = accountInfos[4];
+        const [decodedPoolState, num] = PoolState.decode(poolState.data, 8);
+        const [decodedObservationState, _] = ObservationState.decode(observationState.data, 8);
+        const [decodedPrevTickArrayState, __] = TickArrayState.decode(prevTickArrayState.data, 8);
+        const [decodedCurrentTickArrayState, ___] = TickArrayState.decode(currentTickArrayState.data, 8);
+        const [decodedNextTickArrayState, ____] = TickArrayState.decode(nextTickArrayState.data, 8);
+
+        const currentTime = new BN(Math.floor(Date.now() / 1000));
+
+        let primaryPrice = RaydiumCLMMOracle.getTwapPrimary(
+            decodedObservationState.observations, decodedObservationState.observationIndex,
+            oracleParams.twapSecondsAgo, oracleParams.twapSecondarySecondsAgo,
+            decodedPoolState.mintDecimals0, decodedPoolState.mintDecimals1,
+            currentTime);
+
+        let secondaryPrice = RaydiumCLMMOracle.getTwapSecondary(
+            decodedObservationState.observations, decodedObservationState.observationIndex,
+            oracleParams.twapSecondsAgo, oracleParams.twapSecondarySecondsAgo,
+            decodedPoolState.mintDecimals0, decodedPoolState.mintDecimals1,
+            currentTime);
+        
+        let spotPrice = RaydiumCLMMOracle.getSpotPrice(
+            decodedPoolState.tickCurrent,
+            decodedPoolState.mintDecimals0,
+            decodedPoolState.mintDecimals1);
+
+        // Validate primary TWAP is not zero
+        if (primaryPrice.eq(0)) {
+            return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+        }
+
+        // === 1. Min liquidity and price impact validation (FIRST) ===
+        if (oracleParams.minLiquidity.gt(new BN(0))) {
+            const impactBps = RaydiumCLMMOracle.calculateMaxPriceImpactForMinLiquidity(
+                oracleParams,
+                decodedPoolState,
+                decodedPrevTickArrayState,
+                decodedCurrentTickArrayState,
+                decodedNextTickArrayState,
+                solPrice,
+                usdPrice
+            );
+            if (oracleParams.maxSlippageBps > 0 && impactBps.gt(new Decimal(oracleParams.maxSlippageBps))) {
+                return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+            }
+        }
+
+        // === 2. Confidence calculation ===
+        let maxPrice = Decimal.max(primaryPrice, secondaryPrice, spotPrice);
+        let minPrice = Decimal.min(primaryPrice, secondaryPrice, spotPrice);
+        let confidence = maxPrice.gt(minPrice) ? maxPrice.sub(minPrice) : new Decimal(0);
+        const lastUpdateTimestamp = decodedObservationState.observations[decodedObservationState.observationIndex].blockTimestamp;
+
+        // === 3. Inflate confidence by staleness ===
+        const deltaSecondsBN = currentTime.sub(lastUpdateTimestamp);
+        const deltaSeconds = new Decimal(deltaSecondsBN.toString());
+        if (oracleParams.stalenessConfRateBps > 0 && deltaSeconds.gt(0)) {
+            const stalenessRate = new Decimal(oracleParams.stalenessConfRateBps).div(new Decimal(10000));
+            const inflateFactor = new Decimal(1).add(deltaSeconds.mul(stalenessRate));
+            confidence = confidence.mul(inflateFactor);
+        }
+
+        // === 4. Validate confidence threshold ===
+        const confRatioBps = confidence.div(primaryPrice).mul(new Decimal(HUNDRED_PERCENT_BPS));
+        if (confRatioBps.gt(new Decimal(oracleParams.confThreshBps))) {
+            return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+        }
+    
+        // === 5. Validate staleness threshold ===
+        if (oracleParams.stalenessThresh.gt(new BN(0))) {
+            if (currentTime.sub(lastUpdateTimestamp).gt(oracleParams.stalenessThresh)) {
+                return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+            }
+        }
+
+        // === 6. Validate volatility threshold ===
+        if (!minPrice.eq(0)) {
+            const volRatioBps = maxPrice.sub(minPrice).div(minPrice).mul(new Decimal(HUNDRED_PERCENT_BPS));
+            if (volRatioBps.gt(new Decimal(oracleParams.volatilityThreshBps))) {
+                return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+            }
+        } else {
+            return new OraclePrice(new Decimal(0), new Decimal(0), 0);
+        }
+
+        // === 7. Convert to USD ===
+        if (oracleParams.quote === Quote.Usdc) {
+            primaryPrice = primaryPrice.mul(usdPrice.price);
+            confidence = confidence.mul(usdPrice.price);
+        } else {
+            primaryPrice = primaryPrice.mul(solPrice.price);
+            confidence = confidence.mul(solPrice.price);
+        }
+
+        return new OraclePrice(primaryPrice, confidence, currentTime.toNumber());
+    }
+
+}
+
+function mulRightShift(val: BN, mulBy: BN): BN {
+  return signedRightShift(val.mul(mulBy), 64, 256);
+}
+
+function signedRightShift(n0: BN, shiftBy: number, bitWidth: number): BN {
+  const twoN0 = n0.toTwos(bitWidth).shrn(shiftBy);
+  twoN0.imaskn(bitWidth - shiftBy + 1);
+  return twoN0.fromTwos(bitWidth - shiftBy);
+}