@symmetry-hq/temp-v3-sdk 0.0.1

package/src/states/oracles/raydiumClmmOracle.ts

@@ -0,0 +1,812 @@
+import Decimal from 'decimal.js';
+
+import { BN } from '@coral-xyz/anchor';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+import { U128_MAX } from './constants';
+import { ErrorCode, Oracle, OracleErrors, OraclePrice, OracleResult } from './oracle';
+
+const CLMM_PROGRAM_ID = new PublicKey("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK");
+const MIN_TICK = -443636;
+const MAX_TICK = 443636;
+
+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]; 
+
+    }
+}
+
+
+
+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: BN;
+    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: BN,
+            liquidity: BN,
+            sqrtPriceX64: BN,
+            tickCurrent: BN,
+            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,
+        ];
+    }
+
+
+}
+
+
+export class RaydiumCLMMOracle extends Oracle{
+    poolId: PublicKey;
+    quoteToken: number;
+    poolState: PoolState;
+    observationState: ObservationState;
+    primarySeconds: number;
+    secondarySeconds: number;
+
+    private constructor(params: {
+        poolId: PublicKey,
+        quoteToken: number,
+        poolState: PoolState,
+        observationState: ObservationState,
+        weight: number,
+        primarySeconds: number,
+        secondarySeconds: number,
+        confThreshBps?: number, 
+        stalenessThresh?: number,
+        volatilityThresh?: number | Decimal, 
+        minLiquidity?: number | Decimal,
+        stalenessConfRateBps?: number
+    }){
+        super(
+            params.weight,
+            params.confThreshBps,
+            params.stalenessThresh,
+            params.volatilityThresh,
+            params.minLiquidity,
+            params.stalenessConfRateBps
+        );
+        
+        this.poolId = params.poolId;
+        this.quoteToken = params.quoteToken;
+        this.poolState = params.poolState;
+        this.observationState = params.observationState;
+        this.primarySeconds = params.primarySeconds;
+        this.secondarySeconds = params.secondarySeconds;
+    };
+
+    static async create(params: {
+        connection: Connection,
+        poolId: PublicKey,
+        quoteToken: number,
+        weight: number,
+        primarySeconds: number,
+        secondarySeconds: number,
+        confThreshBps?: number, 
+        stalenessThresh?: number,
+        volatilityThresh?: number | Decimal, 
+        minLiquidity?: number | Decimal,
+        stalenessConfRateBps?: number
+    }): Promise<RaydiumCLMMOracle> {
+        const { connection, poolId } = params;
+
+        // Fetch poolState
+        const poolAccountInfo = await connection.getAccountInfo(new PublicKey(poolId));
+        if (!poolAccountInfo) throw new Error("Pool account not found");
+        const [poolState, _] = PoolState.decode(poolAccountInfo.data, 8);
+
+        // Fetch observationState from poolState
+        const obsPubkey = poolState.observationKey;
+        const obsAccountInfo = await connection.getAccountInfo(new PublicKey(obsPubkey));
+        if (!obsAccountInfo) throw new Error("Observation account not found");
+        const [observationState, __] = ObservationState.decode(obsAccountInfo.data, 8);
+
+        
+        return new RaydiumCLMMOracle({
+            poolId: poolId,
+            quoteToken: params.quoteToken,
+            poolState: poolState,
+            observationState: observationState,
+            weight: params.weight,
+            primarySeconds: params.primarySeconds,
+            secondarySeconds: params.secondarySeconds,
+            confThreshBps: params.confThreshBps, 
+            stalenessThresh: params.stalenessThresh,
+            volatilityThresh: params.volatilityThresh, 
+            minLiquidity: params.minLiquidity,
+            stalenessConfRateBps: params.stalenessConfRateBps
+        });
+    }
+
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number] {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return PublicKey.findProgramAddressSync(seeds, CLMM_PROGRAM_ID);
+    };
+
+    getObservationAtIndex(index: number) {
+        return this.observationState.observations[index];
+    }
+
+    getObservationAtTimestamp(timestamp: BN, startIndex: number): Observation {
+        let observationCurrent = this.getObservationAtIndex(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(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(prevIndex);
+
+        // Adjust current observation to the target timestamp
+        const result = observationCurrent.adjustToTimestamp(timestamp, observationPrev);
+        return result;
+    }
+
+    getDeltaObservations(currentTime: BN, primarySeconds: number, secondarySeconds: number): Observation[] {
+
+        const obsIndex = this.observationState.observationIndex;
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, obsIndex);
+
+        const observationPrimary = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(primarySeconds))), obsIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+
+        const observationSecondary = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(secondarySeconds))), obsIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+
+        return [observationPrimary,observationSecondary];
+    }
+
+
+    getSqrtPriceX64FromTick(tick: BN): BN {
+
+        let numTick = tick.toNumber();
+        if (!Number.isInteger(numTick)) {
+        throw new Error("tick must be integer");
+        }
+        if (numTick < MIN_TICK || numTick > MAX_TICK) {
+        throw new Error("tick must be in MIN_TICK and MAX_TICK");
+        }
+        const tickAbs: number = numTick < 0 ? numTick * -1 : numTick;
+
+        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 (numTick > 0) ratio = U128_MAX.div(ratio);
+        return ratio;
+    }
+
+    sqrtPriceX64ToPrice(sqrtPriceX64: BN, decimalsA: number, decimalsB: number): Decimal {
+
+        return this.x64ToDecimal(sqrtPriceX64)
+                        .pow(2)
+                        .mul(Decimal.pow(10, decimalsA - decimalsB));
+    }
+
+    x64ToDecimal(num: BN, decimalPlaces?: number): Decimal {
+
+        return new Decimal(num.toString()).div(Decimal.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+    }
+
+    getTwapPrimary(currentTime: BN): Decimal {
+
+        let observation = this.getDeltaObservations(currentTime, this.primarySeconds, this.secondarySeconds)[0];
+
+        let tick = observation.tickCumulative.div(observation.blockTimestamp);
+        let twap = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tick),
+                                                this.poolState.mintDecimals0,
+                                                this.poolState.mintDecimals1);
+        return twap;
+    }
+
+    getTwapSecondary(currentTime: BN): Decimal {
+
+        let observation = this.getDeltaObservations(currentTime, this.primarySeconds, this.secondarySeconds)[1];
+        let tick = observation.tickCumulative.div(observation.blockTimestamp);
+        let twap = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tick),
+                                                this.poolState.mintDecimals0,
+                                                this.poolState.mintDecimals1);
+        return twap;
+    }
+
+    getConfidence(currentTime: BN): Decimal {
+
+        const conf = this.getTwapPrimary(currentTime).sub(this.getTwapSecondary(currentTime)).abs();
+
+        return conf;
+    }
+
+    
+    
+    async fetch(): Promise<OracleResult> {
+        const currentTime = new BN(Math.floor(Date.now() / 1000)); // current UNIX timestamp in seconds
+        
+        const confidence = this.getConfidence(currentTime);
+        
+        const liquidity = this.poolState.liquidity; // assuming poolState is already the decoded data
+        const price = this.getTwapPrimary(currentTime);
+
+        let errors = 0;
+
+        // if (confidence.mul(10_000).greaterThan(this.confThreshBps!)) {
+        //     errors |= ErrorCode.TOO_UNCERTAIN;
+        // }
+        
+        if (liquidity.lt(this.minLiquidity)) {
+            errors |= ErrorCode.NOT_ENOUGH_LIQUIDITY;
+        };
+        let err = new OracleErrors(errors);
+        
+        let oraclePrice = new OraclePrice(price, confidence, currentTime);
+        return new OracleResult(
+            oraclePrice,
+            err
+        )
+    }
+
+
+
+}
+
+function mulRightShift(val: BN, mulBy: BN): BN {
+  return signedRightShift(val.mul(mulBy), 64, 256);
+}
+
+function signedLeftShift(n0: BN, shiftBy: number, bitWidth: number): BN {
+  const twosN0 = n0.toTwos(bitWidth).shln(shiftBy);
+  twosN0.imaskn(bitWidth + 1);
+  return twosN0.fromTwos(bitWidth);
+}
+
+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);
+}