@symmetry-hq/sdk 1.0.1

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

@@ -0,0 +1,120 @@
+import Decimal from 'decimal.js';
+import BN from 'bn.js';
+import { AccountInfo, PublicKey } from '@solana/web3.js';
+import { OracleSettings, Side } from '../../layouts/oracle';
+import { OraclePrice } from './oracle';
+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 VaultState {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: string;
+    constructor(params: {
+        mint: PublicKey;
+        owner: PublicKey;
+        amount: string;
+    });
+    static decode(data: Buffer, offset?: number): [VaultState, 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 {
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number];
+    static getObservationAtIndex(observations: Observation[], index: number): Observation;
+    static getObservationAtTimestamp(timestamp: BN, observations: Observation[], startIndex: number): Observation;
+    static getDeltaObservations(currentTime: BN, observations: Observation[], observationIndex: number, primarySeconds: BN, secondarySeconds: BN): Observation[];
+    static getDecimals(side: Side, mint0Decimals: number, mint1Decimals: number): number;
+    /**
+     * Calculate spot price from pool reserves after subtracting all fees.
+     * Returns: { netBase, netQuote, spotPrice } where spotPrice is in USD per base token.
+     */
+    static getSpotPriceWithReserves(poolState: PoolState, vault0State: VaultState, vault1State: VaultState, side: Side, quotePrice: OraclePrice): {
+        netBase: Decimal;
+        netQuote: Decimal;
+        spotPrice: Decimal;
+    };
+    static getTwapPrimary(currentTime: BN, observations: Observation[], observationIndex: number, side: Side, primarySeconds: BN, secondarySeconds: BN, mint0Decimals: number, mint1Decimals: number): Decimal;
+    static getTwapSecondary(currentTime: BN, observations: Observation[], observationIndex: number, side: Side, primarySeconds: BN, secondarySeconds: BN, mint0Decimals: number, mint1Decimals: number): Decimal;
+    /**
+     * Calculate max price impact for minLiquidity trade in both directions (buy and sell).
+     * Uses constant-product AMM formulas:
+     * - BUY: delta_base_out = netBase * delta_q / (netQuote + delta_q)
+     * - SELL: delta_quote_out = netQuote * delta_base / (netBase + delta_base)
+     */
+    static calculateMaxPriceImpactForMinLiquidity(oracleParams: OracleSettings, netBase: Decimal, netQuote: Decimal, spotPriceUsd: Decimal, quotePrice: OraclePrice): Decimal;
+    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], solPrice: OraclePrice, usdPrice: OraclePrice): OraclePrice;
+}
+export {};

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

@@ -0,0 +1,540 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumCPMMOracle = void 0;
+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 oracle_1 = require("../../layouts/oracle");
+const oracle_2 = require("./oracle");
+const CPMM_PROGRAM_ID = new web3_js_1.PublicKey("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+const DEV_CPMM_PROGRAM_ID = new web3_js_1.PublicKey("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb");
+class Observation {
+    constructor(params) {
+        this.timestamp = params.timestamp;
+        this.cumT0Price = params.cumT0Price;
+        this.cumT1Price = params.cumT1Price;
+    }
+    static decode(data, offset = 0) {
+        const timestamp = new bn_js_1.default(data.subarray(offset, offset + 8), "le");
+        const cumT0Price = new bn_js_1.default(data.subarray(offset + 8, offset + 24), 'le');
+        const cumT1Price = new bn_js_1.default(data.subarray(offset + 24, offset + 40), 'le');
+        return [
+            new Observation({
+                timestamp,
+                cumT0Price,
+                cumT1Price
+            }),
+            offset + 40
+        ];
+    }
+    sub(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Subtraction is only supported between Observation instances");
+        }
+        return new Observation({
+            timestamp: this.timestamp.sub(other.timestamp),
+            cumT0Price: this.cumT0Price.sub(other.cumT0Price),
+            cumT1Price: this.cumT1Price.sub(other.cumT1Price),
+        });
+    }
+    add(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Addition is only supported between Observation instances");
+        }
+        return new Observation({
+            timestamp: this.timestamp.add(other.timestamp),
+            cumT0Price: this.cumT0Price.add(other.cumT0Price),
+            cumT1Price: this.cumT1Price.add(other.cumT1Price),
+        });
+    }
+    getWeightedObservation(time) {
+        const cumT0Price = this.cumT0Price.mul(time).div(this.timestamp);
+        const cumT1Price = this.cumT1Price.mul(time).div(this.timestamp);
+        return new Observation({
+            timestamp: time,
+            cumT0Price,
+            cumT1Price
+        });
+    }
+    adjustToTimestamp(targetTimestamp, observationPrev) {
+        // delta = self.sub(prevPbservation)
+        const delta = this.sub(observationPrev);
+        // weightedDelta = delta.getWeightedObservation(targetTimestamp - self.blockTimestamp)
+        const timeForWeighted = targetTimestamp.sub(this.timestamp);
+        const weightedDelta = delta.getWeightedObservation(timeForWeighted);
+        // return self.add(weightedDelta)
+        return this.add(weightedDelta);
+    }
+    getTwap(side) {
+        let cumPrice = new bn_js_1.default(0);
+        if (side === oracle_1.Side.Base)
+            cumPrice = this.cumT0Price;
+        else
+            cumPrice = this.cumT1Price;
+        return cumPrice.div(this.timestamp);
+    }
+}
+class VaultState {
+    constructor(params) {
+        this.mint = params.mint;
+        this.owner = params.owner;
+        this.amount = params.amount;
+    }
+    static decode(data, offset = 0) {
+        // mint (32)
+        const mint = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+        offset += 32;
+        // owner (32)
+        const owner = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+        offset += 32;
+        // amount u64 (8)
+        const amount = (new bn_js_1.default(data.subarray(offset, offset + 8), 'le')).toString();
+        offset += 8;
+        return [
+            new VaultState({ mint, owner, amount }),
+            offset
+        ];
+    }
+}
+class ObservationState {
+    constructor(params) {
+        this.initialized = params.initialized;
+        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 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,
+                observationIndex,
+                poolId,
+                observations,
+                padding
+            }),
+            cursor
+        ];
+    }
+}
+class PoolState {
+    constructor(params) {
+        this.ammConfig = params.ammConfig;
+        this.poolCreator = params.poolCreator;
+        this.token0Vault = params.token0Vault;
+        this.token1Vault = params.token1Vault;
+        this.lpMint = params.lpMint;
+        this.token0Mint = params.token0Mint;
+        this.token1Mint = params.token1Mint;
+        this.token0Program = params.token0Program;
+        this.token1Program = params.token1Program;
+        this.observationKey = params.observationKey;
+        this.authBump = params.authBump; // u8
+        this.status = params.status; // u8
+        this.lpMintDecimals = params.lpMintDecimals; // u8
+        this.mint0Decimals = params.mint0Decimals; // u8
+        this.mint1Decimals = params.mint1Decimals; // u8
+        this.lpSupply = params.lpSupply; // u64
+        this.protocolFeesToken0 = params.protocolFeesToken0; // u64
+        this.protocolFeesToken1 = params.protocolFeesToken1; // u64
+        this.fundFeesToken0 = params.fundFeesToken0; // u64
+        this.fundFeesToken1 = params.fundFeesToken1; // u64
+        this.openTime = params.openTime; // u64
+        this.recentEpoch = params.recentEpoch; // u64
+        this.creatorFeeOn = params.creatorFeeOn; //u8
+        this.enableCreatorFee = params.enableCreatorFee;
+        this.padding1 = params.padding1; // [u8; 6]
+        this.creatorFeesToken0 = params.creatorFeesToken0; // u64
+        this.creatorFeesToken1 = params.creatorFeesToken1; // u64
+        this.padding = params.padding; // [u64; 28]
+    }
+    static decode(data, offset = 8) {
+        let cursor = offset;
+        const ammConfig = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const poolCreator = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token0Vault = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token1Vault = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const lpMint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token0Mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token1Mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token0Program = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token1Program = 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 authBump = data.readUInt8(cursor);
+        cursor += 1;
+        const status = data.readUInt8(cursor);
+        cursor += 1;
+        const lpMintDecimals = data.readUInt8(cursor);
+        cursor += 1;
+        const mint0Decimals = data.readUInt8(cursor);
+        cursor += 1;
+        const mint1Decimals = data.readUInt8(cursor);
+        cursor += 1;
+        const lpSupply = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        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 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 creatorFeeOn = data.readUInt8(cursor);
+        cursor += 1;
+        const enableCreatorFee = !!data.readUInt8(cursor);
+        cursor += 1;
+        const padding1 = [];
+        for (let i = 0; i < 6; i++) {
+            padding1.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+        const creatorFeesToken0 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const creatorFeesToken1 = new bn_js_1.default(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding = [];
+        for (let i = 0; i < 28; i++) {
+            padding.push(new bn_js_1.default(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        return [
+            new PoolState({
+                ammConfig,
+                poolCreator,
+                token0Vault,
+                token1Vault,
+                lpMint,
+                token0Mint,
+                token1Mint,
+                token0Program,
+                token1Program,
+                observationKey,
+                authBump,
+                status,
+                lpMintDecimals,
+                mint0Decimals,
+                mint1Decimals,
+                lpSupply,
+                protocolFeesToken0,
+                protocolFeesToken1,
+                fundFeesToken0,
+                fundFeesToken1,
+                openTime,
+                recentEpoch,
+                creatorFeeOn,
+                enableCreatorFee,
+                padding1,
+                creatorFeesToken0,
+                creatorFeesToken1,
+                padding,
+            }),
+            cursor,
+        ];
+    }
+}
+class RaydiumCPMMOracle {
+    // poolId: PublicKey;
+    // poolState: PoolState;
+    // observationState: ObservationState;
+    // vault0: VaultState;
+    // vault1: VaultState;
+    // constructor(
+    //     oracleParams: OracleSettings,
+    //     cpmmParams: {
+    //     poolId: PublicKey;
+    //     poolState: PoolState;
+    //     observationState: ObservationState,
+    //     vault0: VaultState,
+    //     vault1: VaultState,   
+    // }){
+    //     super(
+    //         oracleParams
+    //     );
+    //     this.poolId = cpmmParams.poolId;
+    //     this.poolState = cpmmParams.poolState;
+    //     this.observationState = cpmmParams.observationState;
+    //     this.vault0 = cpmmParams.vault0;
+    //     this.vault1 = cpmmParams.vault1;
+    // }
+    static deriveObservationKey(poolId) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CPMM_PROGRAM_ID);
+    }
+    ;
+    static getObservationAtIndex(observations, index) {
+        return observations[index];
+    }
+    static getObservationAtTimestamp(timestamp, observations, startIndex) {
+        let observationCurrent = this.getObservationAtIndex(observations, startIndex);
+        let index = startIndex;
+        // Loop backwards until we find the observation <= timestamp
+        while (observationCurrent.timestamp.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");
+            }
+        }
+        // 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 obsIndex = observationIndex;
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, observations, obsIndex);
+        const observationPrimary = this.getObservationAtTimestamp(currentTime.sub(primarySeconds), observations, obsIndex);
+        const deltaPrimary = observationCurrent.sub(observationPrimary);
+        const observationSecondary = this.getObservationAtTimestamp(currentTime.sub(secondarySeconds), observations, obsIndex);
+        const deltaSecondary = observationCurrent.sub(observationSecondary);
+        return [deltaPrimary, deltaSecondary];
+    }
+    ;
+    static getDecimals(side, mint0Decimals, mint1Decimals) {
+        let dec;
+        if (side === oracle_1.Side.Base)
+            dec = mint0Decimals - mint1Decimals;
+        else
+            dec = mint1Decimals - mint0Decimals;
+        return dec;
+    }
+    // static getSpotPrice(
+    //     baseAmount: BN, quoteAmount: BN, protocolFeesToken0: BN, protocolFeesToken1: BN,
+    //     fundFeesToken0: BN, fundFeesToken1: BN, mint0Decimals: number, mint1Decimals: number, side: Side
+    // ): Decimal {
+    //     let decimals = this.getDecimals(side, mint0Decimals, mint1Decimals);
+    //     let fees0 = protocolFeesToken0.add(fundFeesToken0);
+    //     let fees1 = protocolFeesToken1.add(fundFeesToken1);
+    //     if(side === Side.Base) {
+    //         baseAmount = baseAmount.sub(fees0);
+    //         quoteAmount = quoteAmount.sub(fees1);
+    //     }
+    //     else {
+    //         baseAmount = baseAmount.sub(fees1);
+    //         quoteAmount = quoteAmount.sub(fees0);
+    //     }
+    //     let price_scaled = new Decimal(baseAmount.toString()).div(quoteAmount.toString());
+    //     return price_scaled.div(10 ** decimals);
+    // }
+    /**
+     * Calculate spot price from pool reserves after subtracting all fees.
+     * Returns: { netBase, netQuote, spotPrice } where spotPrice is in USD per base token.
+     */
+    static getSpotPriceWithReserves(poolState, vault0State, vault1State, side, quotePrice) {
+        // Total fees per token (protocol + fund + creator)
+        let fees0 = new decimal_js_1.default(poolState.protocolFeesToken0.toString())
+            .add(new decimal_js_1.default(poolState.fundFeesToken0.toString()))
+            .add(new decimal_js_1.default(poolState.creatorFeesToken0.toString()));
+        let fees1 = new decimal_js_1.default(poolState.protocolFeesToken1.toString())
+            .add(new decimal_js_1.default(poolState.fundFeesToken1.toString()))
+            .add(new decimal_js_1.default(poolState.creatorFeesToken1.toString()));
+        // Swap fees if side is Quote 
+        if (side === oracle_1.Side.Quote) {
+            [fees0, fees1] = [fees1, fees0];
+        }
+        // Get vault balances
+        const baseBalance = new decimal_js_1.default(vault0State.amount);
+        const quoteBalance = new decimal_js_1.default(vault1State.amount);
+        // Net reserves after subtracting fees
+        const netBase = baseBalance.sub(fees0);
+        const netQuote = quoteBalance.sub(fees1);
+        // Guard against zero or negative reserves
+        if (netBase.lte(0) || netQuote.lte(0)) {
+            return { netBase: new decimal_js_1.default(0), netQuote: new decimal_js_1.default(0), spotPrice: new decimal_js_1.default(0) };
+        }
+        // Relative price = netQuote / netBase (quote tokens per 1 base token)
+        // Example: 10,000 USDC / 100 SOL = 100 USDC per SOL
+        const relativePrice = netQuote.div(netBase);
+        // Convert to USD: spotPrice = relativePrice * quotePrice.price
+        // If quote is USDC and quotePrice.price ≈ 1, spotPrice ≈ relativePrice
+        // If quote is WSOL and quotePrice.price = $150, spotPrice = relativePrice * 150
+        const spotPrice = relativePrice.mul(quotePrice.price);
+        return { netBase, netQuote, spotPrice };
+    }
+    static getTwapPrimary(currentTime, observations, observationIndex, side, primarySeconds, secondarySeconds, mint0Decimals, mint1Decimals) {
+        let observation = this.getDeltaObservations(currentTime, observations, observationIndex, primarySeconds, secondarySeconds)[0];
+        // TODO: use constant for 2**32 number is not safe
+        let twap_scaled = new decimal_js_1.default(observation.getTwap(side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.getDecimals(side, mint0Decimals, mint1Decimals));
+        return twap;
+    }
+    static getTwapSecondary(currentTime, observations, observationIndex, side, primarySeconds, secondarySeconds, mint0Decimals, mint1Decimals) {
+        let observation = this.getDeltaObservations(currentTime, observations, observationIndex, primarySeconds, secondarySeconds)[1];
+        // TODO: use constant for 2**32 number is not safe
+        let twap_scaled = new decimal_js_1.default(observation.getTwap(side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.getDecimals(side, mint0Decimals, mint1Decimals));
+        return twap;
+    }
+    /**
+     * Calculate max price impact for minLiquidity trade in both directions (buy and sell).
+     * Uses constant-product AMM formulas:
+     * - BUY: delta_base_out = netBase * delta_q / (netQuote + delta_q)
+     * - SELL: delta_quote_out = netQuote * delta_base / (netBase + delta_base)
+     */
+    static calculateMaxPriceImpactForMinLiquidity(oracleParams, netBase, netQuote, spotPriceUsd, quotePrice) {
+        const minLiquidityUsd = new decimal_js_1.default(oracleParams.minLiquidity.toString());
+        if (spotPriceUsd.lte(0)) {
+            return new decimal_js_1.default(10000); // 100% impact - invalid
+        }
+        // Convert minLiquidity USD to quote tokens
+        // delta_q_tokens = minLiquidityUsd / quotePrice.price
+        const deltaQTokens = minLiquidityUsd.div(quotePrice.price);
+        // Require pool has at least that many quote tokens
+        if (netQuote.lt(deltaQTokens)) {
+            // Not enough liquidity - return max impact (will fail validation)
+            return new decimal_js_1.default(10000); // 100% impact
+        }
+        // === BUY simulation (user spends delta_q quote to receive base) ===
+        // delta_base_buy = netBase * delta_q / (netQuote + delta_q)
+        const denomBuy = netQuote.add(deltaQTokens);
+        const deltaBaseBuy = netBase.mul(deltaQTokens).div(denomBuy);
+        let impactBuy = new decimal_js_1.default(0);
+        if (deltaBaseBuy.gt(0)) {
+            // quote spent in USD = delta_q * quotePrice
+            const quoteUsd = deltaQTokens.mul(quotePrice.price);
+            // execution price in USD per base = quoteUsd / deltaBaseBuy
+            const execPriceBuy = quoteUsd.div(deltaBaseBuy);
+            // impact = |execPrice - spotPrice| / spotPrice
+            const diffBuy = execPriceBuy.sub(spotPriceUsd).abs();
+            impactBuy = diffBuy.div(spotPriceUsd);
+        }
+        // === SELL simulation (user sells base roughly equivalent to minLiquidity USD) ===
+        // Approximate base amount to sell: delta_base_sell = delta_q * netBase / netQuote
+        let deltaBaseSell = new decimal_js_1.default(0);
+        if (netQuote.gt(0)) {
+            deltaBaseSell = deltaQTokens.mul(netBase).div(netQuote);
+        }
+        let impactSell = new decimal_js_1.default(0);
+        if (deltaBaseSell.gt(0)) {
+            // delta_quote_out = netQuote * delta_base_sell / (netBase + delta_base_sell)
+            const denomSell = netBase.add(deltaBaseSell);
+            const deltaQuoteOut = netQuote.mul(deltaBaseSell).div(denomSell);
+            // quote out in USD
+            const quoteOutUsd = deltaQuoteOut.mul(quotePrice.price);
+            // execution price in USD per base = quoteOutUsd / deltaBaseSell
+            const execPriceSell = quoteOutUsd.div(deltaBaseSell);
+            // impact = |execPrice - spotPrice| / spotPrice
+            const diffSell = execPriceSell.sub(spotPriceUsd).abs();
+            impactSell = diffSell.div(spotPriceUsd);
+        }
+        // Take max impact of both sides and convert to bps
+        const maxImpact = decimal_js_1.default.max(impactBuy, impactSell);
+        return maxImpact.mul(new decimal_js_1.default(10000)); // Convert to bps
+    }
+    static fetch(oracleParams, accountInfos, solPrice, usdPrice) {
+        const poolStateInfo = accountInfos[0];
+        const vault0Info = accountInfos[1];
+        const vault1Info = accountInfos[2];
+        const observationStateInfo = accountInfos[3];
+        const [decodedPoolState, _] = PoolState.decode(poolStateInfo.data, 8);
+        const [decodedVault0State, __] = VaultState.decode(vault0Info.data, 0);
+        const [decodedVault1State, ___] = VaultState.decode(vault1Info.data, 0);
+        const [decodedObservationState, ____] = ObservationState.decode(observationStateInfo.data, 8);
+        const currentTime = new bn_js_1.default(Math.floor(Date.now() / 1000));
+        // Determine quote oracle
+        const quotePrice = oracleParams.quote === oracle_1.Quote.Usdc ? usdPrice : solPrice;
+        // Get spot price with reserves
+        const { netBase, netQuote, spotPrice } = this.getSpotPriceWithReserves(decodedPoolState, decodedVault0State, decodedVault1State, oracleParams.side, quotePrice);
+        // Get TWAP prices
+        let primaryPrice = RaydiumCPMMOracle.getTwapPrimary(currentTime, decodedObservationState.observations, decodedObservationState.observationIndex, oracleParams.side, oracleParams.twapSecondsAgo, oracleParams.twapSecondarySecondsAgo, decodedPoolState.mint0Decimals, decodedPoolState.mint1Decimals);
+        let secondaryPrice = RaydiumCPMMOracle.getTwapSecondary(currentTime, decodedObservationState.observations, decodedObservationState.observationIndex, oracleParams.side, oracleParams.twapSecondsAgo, oracleParams.twapSecondarySecondsAgo, decodedPoolState.mint0Decimals, decodedPoolState.mint1Decimals);
+        // Convert TWAP prices to USD
+        const primaryPriceUsd = primaryPrice.mul(quotePrice.price);
+        const secondaryPriceUsd = secondaryPrice.mul(quotePrice.price);
+        // Validate primary TWAP is not zero
+        if (primaryPriceUsd.eq(0)) {
+            return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        // === Min liquidity and price impact validation ===
+        if (oracleParams.minLiquidity.gt(new bn_js_1.default(0))) {
+            const impactBps = this.calculateMaxPriceImpactForMinLiquidity(oracleParams, netBase, netQuote, spotPrice, quotePrice);
+            if (oracleParams.maxSlippageBps > 0) {
+                if (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);
+                }
+            }
+        }
+        // === Confidence calculation ===
+        const maxPrice = decimal_js_1.default.max(primaryPriceUsd, secondaryPriceUsd, spotPrice);
+        const minPrice = decimal_js_1.default.min(primaryPriceUsd, secondaryPriceUsd, spotPrice);
+        let confidence = maxPrice.gt(minPrice) ? maxPrice.sub(minPrice) : new decimal_js_1.default(0);
+        // Get last update timestamp from latest observation
+        const lastUpdateTimestamp = decodedObservationState.observations[decodedObservationState.observationIndex].timestamp;
+        // === Inflate confidence by staleness ===
+        // confidence = confidence * (1 + delta_t * stalenessConfRateBps / 10_000)
+        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);
+        }
+        // === Validate confidence threshold ===
+        // confidence / primaryPrice * 10_000 < confThreshBps
+        const confRatioBps = confidence.div(primaryPriceUsd).mul(new decimal_js_1.default(10000));
+        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);
+        }
+        // === 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);
+            }
+        }
+        // === Validate volatility threshold ===
+        // (maxPrice - minPrice) / minPrice * 10_000 <= volatilityThreshBps
+        if (!minPrice.eq(0)) {
+            const volRatioBps = maxPrice.sub(minPrice).div(minPrice).mul(new decimal_js_1.default(10000));
+            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 {
+            // minPrice == 0 is invalid
+            return new oracle_2.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        return new oracle_2.OraclePrice(primaryPriceUsd, confidence, currentTime.toNumber());
+    }
+}
+exports.RaydiumCPMMOracle = RaydiumCPMMOracle;

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

@@ -0,0 +1 @@
+"use strict";

package/dist/src/states/withdrawBasketFees.d.ts

@@ -0,0 +1,10 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { WithdrawBasketFees } from '../layouts/basket';
+export declare function addFieldsToWithdrawBasketFees(withdrawBasketFees: WithdrawBasketFees): WithdrawBasketFees;
+export declare function fetchWithdrawBasketFees(connection: Connection, withdrawBasketFeesAddress: PublicKey): Promise<WithdrawBasketFees>;
+export declare function fetchWithdrawBasketFeesMultiple(connection: Connection, withdrawBasketFeesAddresses: PublicKey[]): Promise<Map<string, WithdrawBasketFees>>;
+export interface WithdrawBasketFeesFilter {
+    type: "basket" | "manager" | "creator" | "host" | "symmetry";
+    pubkey: string;
+}
+export declare function fetchWithdrawBasketFeesList(connection: Connection, filter?: WithdrawBasketFeesFilter): Promise<WithdrawBasketFees[]>;