@symmetry-hq/temp-v3-sdk 0.0.1

package/dist/src/states/oracles/raydiumClmmOracle.js

@@ -0,0 +1,546 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumCLMMOracle = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const oracle_1 = require("./oracle");
+const CLMM_PROGRAM_ID = new web3_js_1.PublicKey("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK");
+const MIN_TICK = -443636;
+const MAX_TICK = 443636;
+class Observation {
+    constructor(params) {
+        this.blockTimestamp = params.blockTimestamp;
+        this.tickCumulative = params.tickCumulative;
+        this.padding = params.padding;
+    }
+    static decode(data, offset = 0) {
+        const blockTimestamp = new anchor_1.BN(data.readUInt32LE(offset));
+        const tickCumulative = new anchor_1.BN(data.subarray(offset + 4, offset + 12), "le").fromTwos(64);
+        const padding = [];
+        let cursor = offset + 12;
+        for (let i = 0; i < 4; i++) {
+            padding.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        return [
+            new Observation({
+                blockTimestamp,
+                tickCumulative,
+                padding
+            }),
+            cursor
+        ];
+    }
+    sub(other) {
+        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) {
+        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) {
+        // 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, observationPrev) {
+        // 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 {
+    constructor(params) {
+        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, offset = 8) {
+        let cursor = offset;
+        const initialized = data.readUInt8(cursor) !== 0;
+        cursor += 1;
+        const recentEpoch = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const observationIndex = data.readUInt16LE(cursor);
+        cursor += 2;
+        const poolId = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const observations = [];
+        for (let i = 0; i < 100; i++) {
+            let obs;
+            [obs, cursor] = Observation.decode(data, cursor);
+            observations.push(obs);
+        }
+        const padding = [];
+        for (let i = 0; i < 4; i++) {
+            padding.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        return [
+            new ObservationState({ initialized, recentEpoch, observationIndex, poolId, observations, padding }),
+            cursor
+        ];
+    }
+}
+class RewardInfo {
+    constructor(params) {
+        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, offset = 0) {
+        let cursor = offset;
+        const rewardState = data.readUInt8(cursor);
+        cursor += 1;
+        const openTime = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const endTime = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const lastUpdateTime = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const emissionsPerSecondX64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const rewardTotalEmissioned = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const rewardClaimed = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const tokenMint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const tokenVault = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const authority = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const rewardGrowthGlobalX64 = new anchor_1.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 {
+    constructor(params) {
+        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, offset = 8) {
+        let cursor = offset;
+        const bump = [data.readUInt8(cursor)];
+        cursor += 1;
+        const ammConfig = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const owner = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const tokenMint0 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const tokenMint1 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const tokenVault0 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const tokenVault1 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const observationKey = new web3_js_1.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 anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const sqrtPriceX64 = new anchor_1.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 anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const feeGrowthGlobal1X64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const protocolFeesToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocolFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const swapInAmountToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapOutAmountToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapInAmountToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapOutAmountToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const status = data.readUInt8(cursor);
+        cursor += 1;
+        const padding = [];
+        for (let i = 0; i < 7; i++) {
+            padding.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+        // RewardInfos
+        const rewardInfos = [];
+        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 = [];
+        for (let i = 0; i < 16; i++) {
+            tickArrayBitmap.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        const totalFeesToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesClaimedToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesClaimedToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const openTime = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const recentEpoch = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding1 = [];
+        for (let i = 0; i < 24; i++) {
+            padding1.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        const padding2 = [];
+        for (let i = 0; i < 32; i++) {
+            padding2.push(new anchor_1.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,
+        ];
+    }
+}
+class RaydiumCLMMOracle extends oracle_1.Oracle {
+    constructor(params) {
+        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 create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { connection, poolId } = params;
+            // Fetch poolState
+            const poolAccountInfo = yield connection.getAccountInfo(new web3_js_1.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 = yield connection.getAccountInfo(new web3_js_1.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) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CLMM_PROGRAM_ID);
+    }
+    ;
+    getObservationAtIndex(index) {
+        return this.observationState.observations[index];
+    }
+    getObservationAtTimestamp(timestamp, startIndex) {
+        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, primarySeconds, secondarySeconds) {
+        const obsIndex = this.observationState.observationIndex;
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, obsIndex);
+        const observationPrimary = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(primarySeconds))), obsIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+        const observationSecondary = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(secondarySeconds))), obsIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+        return [observationPrimary, observationSecondary];
+    }
+    getSqrtPriceX64FromTick(tick) {
+        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 = numTick < 0 ? numTick * -1 : numTick;
+        let ratio = (tickAbs & 0x1) != 0 ? new anchor_1.BN("18445821805675395072") : new anchor_1.BN("18446744073709551616");
+        if ((tickAbs & 0x2) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18444899583751176192"));
+        if ((tickAbs & 0x4) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18443055278223355904"));
+        if ((tickAbs & 0x8) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18439367220385607680"));
+        if ((tickAbs & 0x10) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18431993317065453568"));
+        if ((tickAbs & 0x20) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18417254355718170624"));
+        if ((tickAbs & 0x40) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18387811781193609216"));
+        if ((tickAbs & 0x80) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18329067761203558400"));
+        if ((tickAbs & 0x100) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("18212142134806163456"));
+        if ((tickAbs & 0x200) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("17980523815641700352"));
+        if ((tickAbs & 0x400) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("17526086738831433728"));
+        if ((tickAbs & 0x800) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("16651378430235570176"));
+        if ((tickAbs & 0x1000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("15030750278694412288"));
+        if ((tickAbs & 0x2000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("12247334978884435968"));
+        if ((tickAbs & 0x4000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("8131365268886854656"));
+        if ((tickAbs & 0x8000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("3584323654725218816"));
+        if ((tickAbs & 0x10000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("696457651848324352"));
+        if ((tickAbs & 0x20000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("26294789957507116"));
+        if ((tickAbs & 0x40000) != 0)
+            ratio = mulRightShift(ratio, new anchor_1.BN("37481735321082"));
+        if (numTick > 0)
+            ratio = constants_1.U128_MAX.div(ratio);
+        return ratio;
+    }
+    sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
+        return this.x64ToDecimal(sqrtPriceX64)
+            .pow(2)
+            .mul(decimal_js_1.default.pow(10, decimalsA - decimalsB));
+    }
+    x64ToDecimal(num, decimalPlaces) {
+        return new decimal_js_1.default(num.toString()).div(decimal_js_1.default.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+    }
+    getTwapPrimary(currentTime) {
+        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) {
+        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) {
+        const conf = this.getTwapPrimary(currentTime).sub(this.getTwapSecondary(currentTime)).abs();
+        return conf;
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = new anchor_1.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 |= oracle_1.ErrorCode.NOT_ENOUGH_LIQUIDITY;
+            }
+            ;
+            let err = new oracle_1.OracleErrors(errors);
+            let oraclePrice = new oracle_1.OraclePrice(price, confidence, currentTime);
+            return new oracle_1.OracleResult(oraclePrice, err);
+        });
+    }
+}
+exports.RaydiumCLMMOracle = RaydiumCLMMOracle;
+function mulRightShift(val, mulBy) {
+    return signedRightShift(val.mul(mulBy), 64, 256);
+}
+function signedLeftShift(n0, shiftBy, bitWidth) {
+    const twosN0 = n0.toTwos(bitWidth).shln(shiftBy);
+    twosN0.imaskn(bitWidth + 1);
+    return twosN0.fromTwos(bitWidth);
+}
+function signedRightShift(n0, shiftBy, bitWidth) {
+    const twoN0 = n0.toTwos(bitWidth).shrn(shiftBy);
+    twoN0.imaskn(bitWidth - shiftBy + 1);
+    return twoN0.fromTwos(bitWidth - shiftBy);
+}

package/dist/src/states/oracles/raydiumCpmmOracle.d.ts

@@ -0,0 +1,139 @@
+import Decimal from 'decimal.js';
+import { BN } from '@coral-xyz/anchor';
+import { Connection, PublicKey } from '@solana/web3.js';
+import { Oracle, OracleResult } from './oracle';
+declare enum Side {
+    Base = 0,
+    Quote = 1
+}
+declare enum Quote {
+    Usdc = 0,
+    Wsol = 1
+}
+declare class Observation {
+    timestamp: BN;
+    cumT0Price: BN;
+    cumT1Price: BN;
+    constructor(params: {
+        timestamp: BN;
+        cumT0Price: BN;
+        cumT1Price: BN;
+    });
+    static decode(data: Buffer, offset?: number): [Observation, number];
+    sub(other: Observation): Observation;
+    add(other: Observation): Observation;
+    getWeightedObservation(time: BN): Observation;
+    adjustToTimestamp(targetTimestamp: BN, observationPrev: Observation): Observation;
+    getTwap(side: Side): BN;
+}
+declare class ObservationState {
+    initialized: boolean;
+    observationIndex: number;
+    poolId: PublicKey;
+    observations: Observation[];
+    lastUpdateTimestamp: BN;
+    padding: BN[];
+    constructor(params: {
+        initialized: boolean;
+        observationIndex: number;
+        poolId: PublicKey;
+        observations: Observation[];
+        lastUpdateTimestamp: BN;
+        padding: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [ObservationState, number];
+}
+declare class PoolState {
+    ammConfig: PublicKey;
+    poolCreator: PublicKey;
+    token0Vault: PublicKey;
+    token1Vault: PublicKey;
+    lpMint: PublicKey;
+    token0Mint: PublicKey;
+    token1Mint: PublicKey;
+    token0Program: PublicKey;
+    token1Program: PublicKey;
+    observationKey: PublicKey;
+    authBump: number;
+    status: number;
+    lpMintDecimals: number;
+    mint0Decimals: number;
+    mint1Decimals: number;
+    lpSupply: BN;
+    protocolFeesToken0: BN;
+    protocolFeesToken1: BN;
+    fundFeesToken0: BN;
+    fundFeesToken1: BN;
+    openTime: BN;
+    recentEpoch: BN;
+    creatorFeeOn: number;
+    enableCreatorFee: boolean;
+    padding1: number[];
+    creatorFeesToken0: BN;
+    creatorFeesToken1: BN;
+    padding: BN[];
+    constructor(params: {
+        ammConfig: PublicKey;
+        poolCreator: PublicKey;
+        token0Vault: PublicKey;
+        token1Vault: PublicKey;
+        lpMint: PublicKey;
+        token0Mint: PublicKey;
+        token1Mint: PublicKey;
+        token0Program: PublicKey;
+        token1Program: PublicKey;
+        observationKey: PublicKey;
+        authBump: number;
+        status: number;
+        lpMintDecimals: number;
+        mint0Decimals: number;
+        mint1Decimals: number;
+        lpSupply: BN;
+        protocolFeesToken0: BN;
+        protocolFeesToken1: BN;
+        fundFeesToken0: BN;
+        fundFeesToken1: BN;
+        openTime: BN;
+        recentEpoch: BN;
+        creatorFeeOn: number;
+        enableCreatorFee: boolean;
+        padding1: number[];
+        creatorFeesToken0: BN;
+        creatorFeesToken1: BN;
+        padding: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [PoolState, number];
+}
+export declare class RaydiumCPMMOracle extends Oracle {
+    poolId: PublicKey;
+    quoteToken: Quote;
+    poolState: PoolState;
+    side: Side;
+    observationState: ObservationState;
+    private constructor();
+    static create(params: {
+        connection: Connection;
+        poolId: PublicKey;
+        quoteToken: Quote;
+        side: Side;
+        weight: number;
+        confThreshBps?: number;
+        stalenessThresh?: number;
+        volatilityThresh?: number | Decimal;
+        minLiquidity?: number | Decimal;
+        stalenessConfRateBps?: number;
+    }): Promise<RaydiumCPMMOracle>;
+    setSide(side: Side): void;
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number];
+    getObservationAtIndex(index: number): Observation;
+    getObservationAtTimestamp(timestamp: BN, startIndex: number): Observation;
+    getDeltaObservations(currentTime: BN): Observation[];
+    getDecimals(): number;
+    getTwap30sec(currentTime: BN): Decimal;
+    getTwap2min(currentTime: BN): Decimal;
+    getTwap5min(currentTime: BN): Decimal;
+    getTwap20min(currentTime: BN): Decimal;
+    getConfidence(currentTime: BN): Decimal;
+    fetch(): Promise<OracleResult>;
+}
+export {};