@symmetry-hq/sdk 1.0.1

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

@@ -0,0 +1,843 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumCLMMOracle = exports.PoolState = void 0;
+exports.i32ToBytes = i32ToBytes;
+exports.getTickArrayStartIndexByTick = getTickArrayStartIndexByTick;
+exports.getNextTickArrayStartIndex = getNextTickArrayStartIndex;
+exports.getPdaTickArrayAddress = getPdaTickArrayAddress;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../../constants");
+const oracle_1 = require("../../layouts/oracle");
+const constants_2 = require("./constants");
+const oracle_2 = require("./oracle");
+const CLMM_PROGRAM_ID = new web3_js_1.PublicKey("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK");
+const TICK_ARRAY_SEED = Buffer.from("tick_array");
+const MIN_TICK = -443636;
+const MAX_TICK = 443636;
+function i32ToBytes(num) {
+    const arr = new ArrayBuffer(4);
+    const view = new DataView(arr);
+    view.setInt32(0, num, false);
+    return new Uint8Array(arr);
+}
+function getTickArrayStartIndexByTick(tickIndex, tickSpacing) {
+    const perArray = TICK_ARRAY_SIZE_USIZE * tickSpacing;
+    return Math.floor(tickIndex / perArray) * perArray;
+}
+function getNextTickArrayStartIndex(lastStart, tickSpacing, zeroForOne) {
+    return zeroForOne ? lastStart - tickSpacing * TICK_ARRAY_SIZE_USIZE : lastStart + tickSpacing * TICK_ARRAY_SIZE_USIZE;
+}
+function getPdaTickArrayAddress(poolId, startIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([TICK_ARRAY_SEED, poolId.toBuffer(), i32ToBytes(startIndex)], CLMM_PROGRAM_ID)[0];
+}
+class Observation {
+    constructor(params) {
+        this.blockTimestamp = params.blockTimestamp;
+        this.tickCumulative = params.tickCumulative;
+        this.padding = params.padding;
+    }
+    static decode(data, offset = 0) {
+        const blockTimestamp = new bn_js_1.default(data.readUInt32LE(offset));
+        const tickCumulative = new bn_js_1.default(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 bn_js_1.default(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 bn_js_1.default(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 bn_js_1.default(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 bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const endTime = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const lastUpdateTime = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const emissionsPerSecondX64 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const rewardTotalEmissioned = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const rewardClaimed = new bn_js_1.default(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 bn_js_1.default(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 bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const sqrtPriceX64 = new bn_js_1.default(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_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const feeGrowthGlobal1X64 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const protocolFeesToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocolFeesToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const swapInAmountToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapOutAmountToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapInAmountToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swapOutAmountToken0 = new bn_js_1.default(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 bn_js_1.default(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        const totalFeesToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesClaimedToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const totalFeesClaimedToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const openTime = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const recentEpoch = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding1 = [];
+        for (let i = 0; i < 24; i++) {
+            padding1.push(new bn_js_1.default(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        const padding2 = [];
+        for (let i = 0; i < 32; i++) {
+            padding2.push(new bn_js_1.default(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,
+        ];
+    }
+}
+exports.PoolState = PoolState;
+const TICK_ARRAY_SIZE_USIZE = 60;
+const REWARD_NUM = 3;
+class TickState {
+    constructor(params) {
+        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, offset = 0) {
+        let cursor = offset;
+        const tick = data.readInt32LE(cursor);
+        cursor += 4;
+        // liquidity_net: i128 (signed)
+        const liquidityNet = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le").fromTwos(128);
+        cursor += 16;
+        // liquidity_gross: u128
+        const liquidityGross = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const feeGrowthOutside0X64 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const feeGrowthOutside1X64 = new bn_js_1.default(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const rewardGrowthsOutsideX64 = [];
+        for (let i = 0; i < REWARD_NUM; i++) {
+            rewardGrowthsOutsideX64.push(new bn_js_1.default(data.subarray(cursor, cursor + 16), "le"));
+            cursor += 16;
+        }
+        const padding = [];
+        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 {
+    constructor(params) {
+        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, offset = 8) {
+        let cursor = offset;
+        const poolId = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const startTickIndex = data.readInt32LE(cursor);
+        cursor += 4;
+        const ticks = [];
+        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_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding = [];
+        for (let i = 0; i < 107; i++) {
+            padding.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+        return [
+            new TickArrayState({
+                poolId,
+                startTickIndex,
+                ticks,
+                initializedTickCount,
+                recentEpoch,
+                padding
+            }),
+            cursor
+        ];
+    }
+}
+class RaydiumCLMMOracle {
+    static deriveObservationKey(poolId) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CLMM_PROGRAM_ID);
+    }
+    ;
+    static getObservationAtIndex(observations, index) {
+        return observations[index];
+    }
+    static getObservationAtTimestamp(timestamp, observations, startIndex) {
+        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, observations, observationIndex, primarySeconds, secondarySeconds) {
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, observations, observationIndex);
+        const observationPrimary = this.getObservationAtTimestamp(new bn_js_1.default(currentTime.sub(primarySeconds)), observations, observationIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+        const observationSecondary = this.getObservationAtTimestamp(new bn_js_1.default(currentTime.sub(secondarySeconds)), observations, observationIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+        return [deltaPrimary, deltaSecondary];
+    }
+    static getSqrtPriceX64FromTick(tick) {
+        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 = tick < 0 ? tick * -1 : tick;
+        let ratio = (tickAbs & 0x1) != 0 ? new bn_js_1.default("18445821805675395072") : new bn_js_1.default("18446744073709551616");
+        if ((tickAbs & 0x2) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18444899583751176192"));
+        if ((tickAbs & 0x4) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18443055278223355904"));
+        if ((tickAbs & 0x8) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18439367220385607680"));
+        if ((tickAbs & 0x10) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18431993317065453568"));
+        if ((tickAbs & 0x20) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18417254355718170624"));
+        if ((tickAbs & 0x40) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18387811781193609216"));
+        if ((tickAbs & 0x80) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18329067761203558400"));
+        if ((tickAbs & 0x100) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("18212142134806163456"));
+        if ((tickAbs & 0x200) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("17980523815641700352"));
+        if ((tickAbs & 0x400) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("17526086738831433728"));
+        if ((tickAbs & 0x800) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("16651378430235570176"));
+        if ((tickAbs & 0x1000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("15030750278694412288"));
+        if ((tickAbs & 0x2000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("12247334978884435968"));
+        if ((tickAbs & 0x4000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("8131365268886854656"));
+        if ((tickAbs & 0x8000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("3584323654725218816"));
+        if ((tickAbs & 0x10000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("696457651848324352"));
+        if ((tickAbs & 0x20000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("26294789957507116"));
+        if ((tickAbs & 0x40000) != 0)
+            ratio = mulRightShift(ratio, new bn_js_1.default("37481735321082"));
+        if (tick > 0)
+            ratio = constants_2.U128_MAX.div(ratio);
+        return ratio;
+    }
+    static sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
+        return this.x64ToDecimal(sqrtPriceX64)
+            .pow(2)
+            .mul(decimal_js_1.default.pow(10, decimalsA - decimalsB));
+    }
+    static x64ToDecimal(num, decimalPlaces) {
+        return new decimal_js_1.default(num.toString()).div(decimal_js_1.default.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+    }
+    static getSpotPrice(tickCurrent, mintDecimals0, mintDecimals1) {
+        let price = this.sqrtPriceX64ToPrice(this.getSqrtPriceX64FromTick(tickCurrent), mintDecimals0, mintDecimals1);
+        return price;
+    }
+    static getTwapPrimary(observations, observationIndex, primarySeconds, secondarySeconds, mintDecimals0, mintDecimals1, currentTime) {
+        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, observationIndex, primarySeconds, secondarySeconds, mintDecimals0, mintDecimals1, currentTime) {
+        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, observationIndex, primarySeconds, secondarySeconds, tickCurrent, mintDecimals0, mintDecimals1, currentTime) {
+        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_js_1.default.max(first, second, third);
+        return conf;
+    }
+    static calculateMaxPriceImpactForMinLiquidity(oracleParams, poolState, prevTickArray, currentTickArray, nextTickArray, solPrice, usdPrice) {
+        // local helpers / aliases
+        const sStart = this.x64ToDecimal(poolState.sqrtPriceX64);
+        const Lstart = new decimal_js_1.default(poolState.liquidity.toString());
+        const spotPrice = this.sqrtPriceX64ToPrice(poolState.sqrtPriceX64, poolState.mintDecimals0, poolState.mintDecimals1);
+        const minLiquidityUsd = new decimal_js_1.default(oracleParams.minLiquidity.toString());
+        let amountQuote;
+        if (oracleParams.quote === oracle_1.Quote.Usdc) {
+            amountQuote = minLiquidityUsd.mul(new decimal_js_1.default(10).pow(6)).div(usdPrice.price);
+        }
+        else {
+            amountQuote = minLiquidityUsd.mul(new decimal_js_1.default(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();
+        const prevIdxs = [];
+        const currIdxs = [];
+        const nextIdxs = [];
+        const pushTicks = (ta, outArr) => {
+            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_js_1.default(0)))
+                    outArr.push(tickVal);
+            }
+        };
+        pushTicks(prevTickArray, prevIdxs);
+        pushTicks(currentTickArray, currIdxs);
+        pushTicks(nextTickArray, nextIdxs);
+        // findTickState map lookup
+        const findTickState = (idx) => {
+            var _a;
+            if (idx === null)
+                return null;
+            return (_a = tickMap.get(idx)) !== null && _a !== void 0 ? _a : 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, forward) => {
+            const lists = forward ? [currIdxs, nextIdxs] : [currIdxs, prevIdxs];
+            let best = 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) => tickIdx === null ? null : this.x64ToDecimal(this.getSqrtPriceX64FromTick(tickIdx));
+        // simulate quote -> base (s increases). returns avg quote-per-base or null
+        const simulateIncrease = (amountQ) => {
+            let remaining = amountQ;
+            let s = sStart;
+            let L = Lstart;
+            let totalBaseOut = new decimal_js_1.default(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_js_1.default(1).div(s).sub(new decimal_js_1.default(1).div(sEnd))));
+                    remaining = new decimal_js_1.default(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_js_1.default(1).div(s).sub(new decimal_js_1.default(1).div(sEnd))));
+                    remaining = new decimal_js_1.default(0);
+                    break;
+                }
+                // consume whole segment to boundary
+                totalBaseOut = totalBaseOut.add(L.mul(new decimal_js_1.default(1).div(s).sub(new decimal_js_1.default(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_js_1.default(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) => {
+            const amountBase = amountQ.div(spotPrice);
+            let remainingBase = amountBase;
+            let s = sStart;
+            let L = Lstart;
+            let totalQuoteOut = new decimal_js_1.default(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_js_1.default(0);
+                    break;
+                }
+                const deltaAtoBoundary = L.mul(new decimal_js_1.default(1).div(sBoundary).sub(new decimal_js_1.default(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_js_1.default(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_js_1.default(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) => !avg || avg.lte(0) ? new decimal_js_1.default(0) : avg.sub(spotPrice).abs().div(spotPrice).mul(new decimal_js_1.default(10000));
+        return decimal_js_1.default.max(toImpact(up), toImpact(down));
+    }
+    static fetch(oracleParams, accountInfos, solPrice, usdPrice) {
+        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_js_1.default(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 oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        // === 1. Min liquidity and price impact validation (FIRST) ===
+        if (oracleParams.minLiquidity.gt(new bn_js_1.default(0))) {
+            const impactBps = RaydiumCLMMOracle.calculateMaxPriceImpactForMinLiquidity(oracleParams, decodedPoolState, decodedPrevTickArrayState, decodedCurrentTickArrayState, decodedNextTickArrayState, solPrice, usdPrice);
+            if (oracleParams.maxSlippageBps > 0 && impactBps.gt(new decimal_js_1.default(oracleParams.maxSlippageBps))) {
+                return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+            }
+        }
+        // === 2. Confidence calculation ===
+        let maxPrice = decimal_js_1.default.max(primaryPrice, secondaryPrice, spotPrice);
+        let minPrice = decimal_js_1.default.min(primaryPrice, secondaryPrice, spotPrice);
+        let confidence = maxPrice.gt(minPrice) ? maxPrice.sub(minPrice) : new decimal_js_1.default(0);
+        const lastUpdateTimestamp = decodedObservationState.observations[decodedObservationState.observationIndex].blockTimestamp;
+        // === 3. Inflate confidence by staleness ===
+        const deltaSecondsBN = currentTime.sub(lastUpdateTimestamp);
+        const deltaSeconds = new decimal_js_1.default(deltaSecondsBN.toString());
+        if (oracleParams.stalenessConfRateBps > 0 && deltaSeconds.gt(0)) {
+            const stalenessRate = new decimal_js_1.default(oracleParams.stalenessConfRateBps).div(new decimal_js_1.default(10000));
+            const inflateFactor = new decimal_js_1.default(1).add(deltaSeconds.mul(stalenessRate));
+            confidence = confidence.mul(inflateFactor);
+        }
+        // === 4. Validate confidence threshold ===
+        const confRatioBps = confidence.div(primaryPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+        if (confRatioBps.gt(new decimal_js_1.default(oracleParams.confThreshBps))) {
+            return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        // === 5. Validate staleness threshold ===
+        if (oracleParams.stalenessThresh.gt(new bn_js_1.default(0))) {
+            if (currentTime.sub(lastUpdateTimestamp).gt(oracleParams.stalenessThresh)) {
+                return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+            }
+        }
+        // === 6. Validate volatility threshold ===
+        if (!minPrice.eq(0)) {
+            const volRatioBps = maxPrice.sub(minPrice).div(minPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+            if (volRatioBps.gt(new decimal_js_1.default(oracleParams.volatilityThreshBps))) {
+                return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+            }
+        }
+        else {
+            return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        // === 7. Convert to USD ===
+        if (oracleParams.quote === oracle_1.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 oracle_2.OraclePrice(primaryPrice, confidence, currentTime.toNumber());
+    }
+}
+exports.RaydiumCLMMOracle = RaydiumCLMMOracle;
+function mulRightShift(val, mulBy) {
+    return signedRightShift(val.mul(mulBy), 64, 256);
+}
+function signedRightShift(n0, shiftBy, bitWidth) {
+    const twoN0 = n0.toTwos(bitWidth).shrn(shiftBy);
+    twoN0.imaskn(bitWidth - shiftBy + 1);
+    return twoN0.fromTwos(bitWidth - shiftBy);
+}