@symmetry-hq/temp-v3-sdk 0.0.1

package/dist/src/states/oracles/clmm_oracle.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.block_timestamp = params.block_timestamp;
+        this.tick_cumulative = params.tick_cumulative;
+        this.padding = params.padding;
+    }
+    static decode(data, offset = 0) {
+        const block_timestamp = new anchor_1.BN(data.readUInt32LE(offset));
+        const tick_cumulative = 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({
+                block_timestamp,
+                tick_cumulative,
+                padding
+            }),
+            cursor
+        ];
+    }
+    sub(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Subtraction is only supported between Observation instances");
+        }
+        return new Observation({
+            block_timestamp: this.block_timestamp.sub(other.block_timestamp),
+            tick_cumulative: this.tick_cumulative.sub(other.tick_cumulative),
+            padding: this.padding
+        });
+    }
+    add(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Addition is only supported between Observation instances");
+        }
+        return new Observation({
+            block_timestamp: this.block_timestamp.add(other.block_timestamp),
+            tick_cumulative: this.tick_cumulative.add(other.tick_cumulative),
+            padding: this.padding
+        });
+    }
+    get_weighted_observation(time) {
+        // cum_t = (self.tick_cumulative * time) / self.block_timestamp
+        const cum = this.tick_cumulative.mul(time).div(this.block_timestamp);
+        return new Observation({
+            block_timestamp: time,
+            tick_cumulative: cum,
+            padding: this.padding
+        });
+    }
+    adjust_to_timestamp(target_timestamp, observation_prev) {
+        // delta = self.sub(prev_observation)
+        const delta = this.sub(observation_prev);
+        // weighted_delta = delta.get_weighted_observation(target_timestamp - self.block_timestamp)
+        const timeForWeighted = target_timestamp.sub(this.block_timestamp);
+        const weighted_delta = delta.get_weighted_observation(timeForWeighted);
+        // return self.add(weighted_delta)
+        return this.add(weighted_delta);
+    }
+}
+class ObservationState {
+    constructor(params) {
+        this.initialized = params.initialized;
+        this.recent_epoch = params.recent_epoch;
+        this.observation_index = params.observation_index;
+        this.pool_id = params.pool_id;
+        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 recent_epoch = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const observation_index = data.readUInt16LE(cursor);
+        cursor += 2;
+        const pool_id = 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, recent_epoch, observation_index, pool_id, observations, padding }),
+            cursor
+        ];
+    }
+}
+class RewardInfo {
+    constructor(params) {
+        this.reward_state = params.reward_state;
+        this.open_time = params.open_time;
+        this.end_time = params.end_time;
+        this.last_update_time = params.last_update_time;
+        this.emissions_per_second_x64 = params.emissions_per_second_x64;
+        this.reward_total_emissioned = params.reward_total_emissioned;
+        this.reward_claimed = params.reward_claimed;
+        this.token_mint = params.token_mint;
+        this.token_vault = params.token_vault;
+        this.authority = params.authority;
+        this.reward_growth_global_x64 = params.reward_growth_global_x64;
+    }
+    static decode(data, offset = 0) {
+        let cursor = offset;
+        const reward_state = data.readUInt8(cursor);
+        cursor += 1;
+        const open_time = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const end_time = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const last_update_time = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const emissions_per_second_x64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const reward_total_emissioned = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const reward_claimed = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const token_mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_vault = 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 reward_growth_global_x64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        return [new RewardInfo({
+                reward_state,
+                open_time,
+                end_time,
+                last_update_time,
+                emissions_per_second_x64,
+                reward_total_emissioned,
+                reward_claimed,
+                token_mint,
+                token_vault,
+                authority,
+                reward_growth_global_x64
+            }), cursor];
+    }
+}
+class PoolState {
+    constructor(params) {
+        this.bump = params.bump;
+        this.amm_config = params.amm_config;
+        this.owner = params.owner;
+        this.token_mint_0 = params.token_mint_0;
+        this.token_mint_1 = params.token_mint_1;
+        this.token_vault_0 = params.token_vault_0;
+        this.token_vault_1 = params.token_vault_1;
+        this.observation_key = params.observation_key;
+        this.mint_decimals_0 = params.mint_decimals_0;
+        this.mint_decimals_1 = params.mint_decimals_1;
+        this.tick_spacing = params.tick_spacing;
+        this.liquidity = params.liquidity;
+        this.sqrt_price_x64 = params.sqrt_price_x64;
+        this.tick_current = params.tick_current;
+        this.padding3 = params.padding3;
+        this.padding4 = params.padding4;
+        this.fee_growth_global_0_x64 = params.fee_growth_global_0_x64;
+        this.fee_growth_global_1_x64 = params.fee_growth_global_1_x64;
+        this.protocol_fees_token_0 = params.protocol_fees_token_0;
+        this.protocol_fees_token_1 = params.protocol_fees_token_1;
+        this.swap_in_amount_token_0 = params.swap_in_amount_token_0;
+        this.swap_out_amount_token_1 = params.swap_out_amount_token_1;
+        this.swap_in_amount_token_1 = params.swap_in_amount_token_1;
+        this.swap_out_amount_token_0 = params.swap_out_amount_token_0;
+        this.status = params.status;
+        this.padding = params.padding;
+        this.reward_infos = params.reward_infos;
+        this.tick_array_bitmap = params.tick_array_bitmap;
+        this.total_fees_token_0 = params.total_fees_token_0;
+        this.total_fees_claimed_token_0 = params.total_fees_claimed_token_0;
+        this.total_fees_token_1 = params.total_fees_token_1;
+        this.total_fees_claimed_token_1 = params.total_fees_claimed_token_1;
+        this.fund_fees_token_0 = params.fund_fees_token_0;
+        this.fund_fees_token_1 = params.fund_fees_token_1;
+        this.open_time = params.open_time;
+        this.recent_epoch = params.recent_epoch;
+        this.padding1 = params.padding1;
+        this.padding2 = params.padding2;
+    }
+    static decode(data, offset = 8) {
+        let cursor = offset;
+        const bump = [data.readUInt8(cursor)];
+        cursor += 1;
+        const amm_config = 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 token_mint_0 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_mint_1 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_vault_0 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_vault_1 = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const observation_key = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const mint_decimals_0 = data.readUInt8(cursor);
+        cursor += 1;
+        const mint_decimals_1 = data.readUInt8(cursor);
+        cursor += 1;
+        const tick_spacing = data.readUInt16LE(cursor);
+        cursor += 2;
+        const liquidity = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const sqrt_price_x64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const tick_current = data.readInt32LE(cursor);
+        cursor += 4;
+        const padding3 = data.readUInt16LE(cursor);
+        cursor += 2;
+        const padding4 = data.readUInt16LE(cursor);
+        cursor += 2;
+        const fee_growth_global_0_x64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const fee_growth_global_1_x64 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const protocol_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocol_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const swap_in_amount_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swap_out_amount_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swap_in_amount_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 16), "le");
+        cursor += 16;
+        const swap_out_amount_token_0 = 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 reward_infos = [];
+        for (let i = 0; i < 3; i++) {
+            const decoded = RewardInfo.decode(data, cursor);
+            reward_infos.push(decoded[0]);
+            cursor = decoded[1];
+        }
+        // tick_array_bitmap [u64;16]
+        const tick_array_bitmap = [];
+        for (let i = 0; i < 16; i++) {
+            tick_array_bitmap.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        const total_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const total_fees_claimed_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const total_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const total_fees_claimed_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fund_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fund_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const open_time = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const recent_epoch = 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,
+                amm_config,
+                owner,
+                token_mint_0,
+                token_mint_1,
+                token_vault_0,
+                token_vault_1,
+                observation_key,
+                mint_decimals_0,
+                mint_decimals_1,
+                tick_spacing,
+                liquidity,
+                sqrt_price_x64,
+                tick_current,
+                padding3,
+                padding4,
+                fee_growth_global_0_x64,
+                fee_growth_global_1_x64,
+                protocol_fees_token_0,
+                protocol_fees_token_1,
+                swap_in_amount_token_0,
+                swap_out_amount_token_1,
+                swap_in_amount_token_1,
+                swap_out_amount_token_0,
+                status,
+                padding,
+                reward_infos,
+                tick_array_bitmap,
+                total_fees_token_0,
+                total_fees_claimed_token_0,
+                total_fees_token_1,
+                total_fees_claimed_token_1,
+                fund_fees_token_0,
+                fund_fees_token_1,
+                open_time,
+                recent_epoch,
+                padding1,
+                padding2,
+            }),
+            cursor,
+        ];
+    }
+}
+class RaydiumCLMMOracle extends oracle_1.Oracle {
+    constructor(params) {
+        super(params.weight, params.conf_thresh_bps, params.staleness_thresh, params.volatility_thresh, params.min_liquidity, params.staleness_conf_rate_bps);
+        this.pool_id = params.pool_id;
+        this.quote_token = params.quote_token;
+        this.pool_state = params.pool_state;
+        this.observation_state = params.observation_state;
+        this.primary_seconds = params.primary_seconds;
+        this.secondary_seconds = params.secondary_seconds;
+    }
+    ;
+    static create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { connection, pool_id } = params;
+            // Fetch pool_state
+            const poolAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(pool_id));
+            if (!poolAccountInfo)
+                throw new Error("Pool account not found");
+            const [pool_state, _] = PoolState.decode(poolAccountInfo.data, 8);
+            // Fetch observation_state from pool_state
+            const obsPubkey = pool_state.observation_key;
+            const obsAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(obsPubkey));
+            if (!obsAccountInfo)
+                throw new Error("Observation account not found");
+            const [observation_state, __] = ObservationState.decode(obsAccountInfo.data, 8);
+            return new RaydiumCLMMOracle({
+                pool_id: pool_id,
+                quote_token: params.quote_token,
+                pool_state: pool_state,
+                observation_state: observation_state,
+                weight: params.weight,
+                primary_seconds: params.primary_seconds,
+                secondary_seconds: params.secondary_seconds,
+                conf_thresh_bps: params.conf_thresh_bps,
+                staleness_thresh: params.staleness_thresh,
+                volatility_thresh: params.volatility_thresh,
+                min_liquidity: params.min_liquidity,
+                staleness_conf_rate_bps: params.staleness_conf_rate_bps
+            });
+        });
+    }
+    static derive_observation_key(poolId) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CLMM_PROGRAM_ID);
+    }
+    ;
+    get_observation_at_index(index) {
+        return this.observation_state.observations[index];
+    }
+    get_observation_at_timestamp(timestamp, startIndex) {
+        let observationCurrent = this.get_observation_at_index(startIndex);
+        let index = startIndex;
+        // const obsIndex = this.observation_state.observation_index;
+        // Loop backwards until we find the observation <= timestamp
+        while (observationCurrent.block_timestamp.gt(timestamp)) {
+            index = (index - 1 + 100) % 100;
+            observationCurrent = this.get_observation_at_index(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.get_observation_at_index(prevIndex);
+        // Adjust current observation to the target timestamp
+        const result = observationCurrent.adjust_to_timestamp(timestamp, observationPrev);
+        return result;
+    }
+    get_delta_observations(currentTime, primary_seconds, secondary_seconds) {
+        const obsIndex = this.observation_state.observation_index;
+        const observationCurrent = this.get_observation_at_timestamp(currentTime, obsIndex);
+        const observationPrimary = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(primary_seconds))), obsIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+        const observationSecondary = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(secondary_seconds))), obsIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+        return [observationPrimary, observationSecondary];
+    }
+    get_sqrt_price_x64_from_tick(tick) {
+        let num_tick = tick.toNumber();
+        if (!Number.isInteger(num_tick)) {
+            throw new Error("tick must be integer");
+        }
+        if (num_tick < MIN_TICK || num_tick > MAX_TICK) {
+            throw new Error("tick must be in MIN_TICK and MAX_TICK");
+        }
+        const tickAbs = num_tick < 0 ? num_tick * -1 : num_tick;
+        let ratio = (tickAbs & 0x1) != 0 ? new anchor_1.BN("18445821805675395072") : new anchor_1.BN("18446744073709551616");
+        if ((tickAbs & 0x2) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18444899583751176192"));
+        if ((tickAbs & 0x4) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18443055278223355904"));
+        if ((tickAbs & 0x8) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18439367220385607680"));
+        if ((tickAbs & 0x10) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18431993317065453568"));
+        if ((tickAbs & 0x20) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18417254355718170624"));
+        if ((tickAbs & 0x40) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18387811781193609216"));
+        if ((tickAbs & 0x80) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18329067761203558400"));
+        if ((tickAbs & 0x100) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("18212142134806163456"));
+        if ((tickAbs & 0x200) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("17980523815641700352"));
+        if ((tickAbs & 0x400) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("17526086738831433728"));
+        if ((tickAbs & 0x800) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("16651378430235570176"));
+        if ((tickAbs & 0x1000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("15030750278694412288"));
+        if ((tickAbs & 0x2000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("12247334978884435968"));
+        if ((tickAbs & 0x4000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("8131365268886854656"));
+        if ((tickAbs & 0x8000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("3584323654725218816"));
+        if ((tickAbs & 0x10000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("696457651848324352"));
+        if ((tickAbs & 0x20000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("26294789957507116"));
+        if ((tickAbs & 0x40000) != 0)
+            ratio = mul_right_shift(ratio, new anchor_1.BN("37481735321082"));
+        if (num_tick > 0)
+            ratio = constants_1.U128_MAX.div(ratio);
+        return ratio;
+    }
+    sqrt_price_x64_to_price(sqrtPriceX64, decimalsA, decimalsB) {
+        return this.x64_to_decimal(sqrtPriceX64)
+            .pow(2)
+            .mul(decimal_js_1.default.pow(10, decimalsA - decimalsB));
+    }
+    x64_to_decimal(num, decimalPlaces) {
+        return new decimal_js_1.default(num.toString()).div(decimal_js_1.default.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+    }
+    get_twap_primary(current_time) {
+        let observation = this.get_delta_observations(current_time, this.primary_seconds, this.secondary_seconds)[0];
+        let tick = observation.tick_cumulative.div(observation.block_timestamp);
+        let twap = this.sqrt_price_x64_to_price(this.get_sqrt_price_x64_from_tick(tick), this.pool_state.mint_decimals_0, this.pool_state.mint_decimals_1);
+        return twap;
+    }
+    get_twap_secondary(current_time) {
+        let observation = this.get_delta_observations(current_time, this.primary_seconds, this.secondary_seconds)[1];
+        let tick = observation.tick_cumulative.div(observation.block_timestamp);
+        let twap = this.sqrt_price_x64_to_price(this.get_sqrt_price_x64_from_tick(tick), this.pool_state.mint_decimals_0, this.pool_state.mint_decimals_1);
+        return twap;
+    }
+    get_confidence(currentTime) {
+        const conf = this.get_twap_primary(currentTime).sub(this.get_twap_secondary(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.get_confidence(currentTime);
+            const liquidity = this.pool_state.liquidity; // assuming pool_state is already the decoded data
+            const price = this.get_twap_primary(currentTime);
+            let errors = 0;
+            // if (confidence.mul(10_000).greaterThan(this.conf_thresh_bps!)) {
+            //     errors |= ErrorCode.TOO_UNCERTAIN;
+            // }
+            if (liquidity.lt(this.min_liquidity)) {
+                errors |= oracle_1.ErrorCode.NOT_ENOUGH_LIQUIDITY;
+            }
+            ;
+            let err = new oracle_1.OracleErrors(errors);
+            let oracle_price = new oracle_1.OraclePrice(price, confidence, currentTime);
+            return new oracle_1.OracleResult(oracle_price, err);
+        });
+    }
+}
+exports.RaydiumCLMMOracle = RaydiumCLMMOracle;
+function mul_right_shift(val, mulBy) {
+    return signed_right_shift(val.mul(mulBy), 64, 256);
+}
+function signed_left_shift(n0, shiftBy, bitWidth) {
+    const twosN0 = n0.toTwos(bitWidth).shln(shiftBy);
+    twosN0.imaskn(bitWidth + 1);
+    return twosN0.fromTwos(bitWidth);
+}
+function signed_right_shift(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/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const U8_MAX: any;
+export declare const U16_MAX: any;
+export declare const U32_MAX: any;
+export declare const U64_MAX: any;
+export declare const U128_MAX: any;
+export declare const HERMES_PUBLIC_ENDPOINT = "https://hermes.pyth.network";
+export declare const SOLANA_DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+export declare const SOLANA_MAINNET_ENDPOINT = "https://api.mainnet-beta.solana.com";

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_MAINNET_ENDPOINT = exports.SOLANA_DEVNET_ENDPOINT = exports.HERMES_PUBLIC_ENDPOINT = exports.U128_MAX = exports.U64_MAX = exports.U32_MAX = exports.U16_MAX = exports.U8_MAX = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+exports.U8_MAX = new anchor_1.BN(0xff);
+exports.U16_MAX = new anchor_1.BN(0xffff);
+exports.U32_MAX = new anchor_1.BN(0xffffffff);
+exports.U64_MAX = new anchor_1.BN(1).shln(64).sub(new anchor_1.BN(1));
+exports.U128_MAX = new anchor_1.BN(1).shln(128).sub(new anchor_1.BN(1));
+exports.HERMES_PUBLIC_ENDPOINT = "https://hermes.pyth.network";
+exports.SOLANA_DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+exports.SOLANA_MAINNET_ENDPOINT = "https://api.mainnet-beta.solana.com";

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

@@ -0,0 +1,60 @@
+import Decimal from 'decimal.js';
+import { BN } from '@coral-xyz/anchor';
+export declare enum ErrorCode {
+    NONE = 0,
+    INVALID_PRICE = 1,
+    TOO_VOLATILE = 2,
+    TOO_UNCERTAIN = 4,
+    STALE = 8,
+    NOT_ENOUGH_LIQUIDITY = 16,
+    NOT_ENABLED = 32,
+    NOT_ENOUGH_ORACLES = 64,
+    MISSING_REQUIRED_ORACLES = 128
+}
+export declare class OracleErrors extends Error {
+    code: ErrorCode;
+    constructor(code: ErrorCode, message?: string);
+    static NONE: OracleErrors;
+    static INVALID_PRICE: OracleErrors;
+    static TOO_VOLATILE: OracleErrors;
+    static TOO_UNCERTAIN: OracleErrors;
+    static STALE: OracleErrors;
+    static NOT_ENOUGH_LIQUIDITY: OracleErrors;
+    static NOT_ENABLED: OracleErrors;
+    static NOT_ENOUGH_ORACLES: OracleErrors;
+    static MISSING_REQUIRED_ORACLES: OracleErrors;
+}
+export declare class OraclePrice {
+    price: Decimal;
+    conf: Decimal;
+    updateTime: BN;
+    mid: Decimal;
+    low: Decimal;
+    high: Decimal;
+    constructor(price: Decimal, conf: Decimal, updateTime: BN);
+}
+export declare class OracleResult {
+    price: OraclePrice | null;
+    error: OracleErrors;
+    constructor(price: OraclePrice | null, error?: OracleErrors);
+    ok(): boolean;
+}
+export declare abstract class Oracle {
+    weight: number;
+    confThreshBps: number;
+    stalenessThresh: number;
+    volatilityThresh: Decimal;
+    minLiquidity: Decimal;
+    stalenessConfRateBps: number;
+    constructor(weight: number, confThreshBps?: number, stalenessThresh?: number, volatilityThresh?: number | Decimal, minLiquidity?: number | Decimal, stalenessConfRateBps?: number);
+    abstract fetch(): Promise<OracleResult>;
+}
+export declare class OracleAggregator {
+    oracles: Oracle[];
+    requiredOracles: Oracle[];
+    minConfBps: number;
+    confThreshBps: number;
+    minOraclesThresh: number;
+    constructor(oracles: Oracle[], requiredOracles: Oracle[], minConfBps?: number, confThreshBps?: number, minOraclesThresh?: number);
+    fetch(): Promise<OracleResult>;
+}