@symmetry-hq/temp-v3-sdk 0.0.1

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

@@ -0,0 +1,420 @@
+"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.RaydiumCPMMOracle = 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 oracle_1 = require("./oracle");
+const CPMM_PROGRAM_ID = new web3_js_1.PublicKey("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+const DEV_CPMM_PROGRAM_ID = new web3_js_1.PublicKey("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb");
+var Side;
+(function (Side) {
+    Side[Side["Base"] = 0] = "Base";
+    Side[Side["Quote"] = 1] = "Quote";
+})(Side || (Side = {}));
+var Quote;
+(function (Quote) {
+    Quote[Quote["Usdc"] = 0] = "Usdc";
+    Quote[Quote["Wsol"] = 1] = "Wsol";
+})(Quote || (Quote = {}));
+class Observation {
+    constructor(params) {
+        this.timestamp = params.timestamp;
+        this.cumT0Price = params.cumT0Price;
+        this.cumT1Price = params.cumT1Price;
+    }
+    static decode(data, offset = 0) {
+        const timestamp = new anchor_1.BN(data.subarray(offset, offset + 8), "le");
+        const cumT0Price = new anchor_1.BN(data.subarray(offset + 8, offset + 24), 'le');
+        const cumT1Price = new anchor_1.BN(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 anchor_1.BN(0);
+        if (side === Side.Base)
+            cumPrice = this.cumT0Price;
+        else
+            cumPrice = this.cumT1Price;
+        console.log("cumPrice", cumPrice.toString());
+        return cumPrice.div(this.timestamp);
+    }
+}
+class ObservationState {
+    constructor(params) {
+        this.initialized = params.initialized;
+        this.observationIndex = params.observationIndex;
+        this.poolId = params.poolId;
+        this.observations = params.observations;
+        this.lastUpdateTimestamp = params.lastUpdateTimestamp;
+        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 lastUpdateTimestamp = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        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,
+                observationIndex,
+                poolId,
+                observations,
+                lastUpdateTimestamp,
+                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 anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocolFeesToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocolFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fundFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const openTime = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const recentEpoch = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const 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 anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const creatorFeesToken1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding = [];
+        for (let i = 0; i < 28; i++) {
+            padding.push(new anchor_1.BN(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 extends oracle_1.Oracle {
+    constructor(params) {
+        super(params.weight, params.confThreshBps, params.stalenessThresh, params.volatilityThresh, params.minLiquidity, params.stalenessConfRateBps);
+        this.poolId = params.poolId;
+        this.quoteToken = params.quoteToken;
+        this.poolState = params.poolState;
+        this.side = params.side;
+        this.observationState = params.observationState;
+    }
+    static create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { connection, poolId } = params;
+            // Fetch pooState
+            const poolAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(poolId));
+            if (!poolAccountInfo)
+                throw new Error("Pool account not found");
+            const [poolState, _] = PoolState.decode(poolAccountInfo.data, 8);
+            // Fetch observationState from poolState
+            const obsPubkey = poolState.observationKey;
+            const obsAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(obsPubkey));
+            if (!obsAccountInfo)
+                throw new Error("Observation account not found");
+            const [observationState, __] = ObservationState.decode(obsAccountInfo.data, 8);
+            return new RaydiumCPMMOracle({
+                poolId: poolId,
+                quoteToken: params.quoteToken,
+                poolState: poolState,
+                side: params.side,
+                observationState: observationState,
+                weight: params.weight,
+                confThreshBps: params.confThreshBps,
+                stalenessThresh: params.stalenessThresh,
+                volatilityThresh: params.volatilityThresh,
+                minLiquidity: params.minLiquidity,
+                stalenessConfRateBps: params.stalenessConfRateBps
+            });
+        });
+    }
+    setSide(side) {
+        this.side = side;
+    }
+    static deriveObservationKey(poolId) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CPMM_PROGRAM_ID);
+    }
+    ;
+    getObservationAtIndex(index) {
+        return this.observationState.observations[index];
+    }
+    getObservationAtTimestamp(timestamp, startIndex) {
+        let observationCurrent = this.getObservationAtIndex(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(index);
+            if (index === startIndex) {
+                throw Error("Observations do not go back far enough in time");
+                break; // looped all the way around
+            }
+        }
+        // Previous index for interpolation
+        const prevIndex = (index - 1 + 100) % 100;
+        const observationPrev = this.getObservationAtIndex(prevIndex);
+        // Adjust current observation to the target timestamp
+        const result = observationCurrent.adjustToTimestamp(timestamp, observationPrev);
+        return result;
+    }
+    getDeltaObservations(currentTime) {
+        const obsIndex = this.observationState.observationIndex;
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, obsIndex);
+        const observation30s = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(30))), obsIndex);
+        const delta30s = observationCurrent.sub(observation30s);
+        const observation2min = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(120))), obsIndex);
+        const delta2min = observationCurrent.sub(observation2min);
+        const observation5min = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(300))), obsIndex);
+        const delta5min = observationCurrent.sub(observation5min);
+        const observation20min = this.getObservationAtTimestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(1200))), obsIndex);
+        const delta20min = observationCurrent.sub(observation20min);
+        return [delta30s, delta2min, delta5min, delta20min];
+    }
+    ;
+    getDecimals() {
+        let dec;
+        if (this.side === Side.Base)
+            dec = this.poolState.mint0Decimals - this.poolState.mint1Decimals;
+        else
+            dec = this.poolState.mint1Decimals - this.poolState.mint0Decimals;
+        return dec;
+    }
+    getTwap30sec(currentTime) {
+        let observation = this.getDeltaObservations(currentTime)[0];
+        let twapScaled = new decimal_js_1.default(observation.getTwap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twapScaled.toString()).div(10 ** this.getDecimals());
+        return twap;
+    }
+    getTwap2min(currentTime) {
+        let observation = this.getDeltaObservations(currentTime)[1];
+        let twapScaled = new decimal_js_1.default(observation.getTwap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twapScaled.toString()).div(10 ** this.getDecimals());
+        return twap;
+    }
+    getTwap5min(currentTime) {
+        let observation = this.getDeltaObservations(currentTime)[2];
+        let twapScaled = new decimal_js_1.default(observation.getTwap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twapScaled.toString()).div(10 ** this.getDecimals());
+        return twap;
+    }
+    getTwap20min(currentTime) {
+        let observation = this.getDeltaObservations(currentTime)[3];
+        let twapScaled = new decimal_js_1.default(observation.getTwap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twapScaled.toString()).div(10 ** this.getDecimals());
+        return twap;
+    }
+    getConfidence(currentTime) {
+        const twapNow = this.getTwap30sec(currentTime);
+        const diff2Min = twapNow.sub(this.getTwap2min(currentTime)).abs();
+        const diff5Min = twapNow.sub(this.getTwap5min(currentTime)).abs();
+        const diff20Min = twapNow.sub(this.getTwap20min(currentTime)).abs();
+        let max = diff2Min;
+        if (diff5Min.gt(max))
+            max = diff5Min;
+        if (diff20Min.gt(max))
+            max = diff20Min;
+        return max;
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = new anchor_1.BN(Math.floor(Date.now() / 1000)); // current UNIX timestamp in seconds
+            const confidence = this.getConfidence(currentTime);
+            // const liquidity = this.poolState.liquidity; // assuming poolState is already the decoded data
+            const price = this.getTwap30sec(currentTime);
+            let errors = 0;
+            // if (confidence.mul(10_000).greaterThan(this.confThreshBps!)) {
+            //     errors |= ErrorCode.TOO_UNCERTAIN;
+            // }
+            // if (liquidity.lt(this.minLiquidity)) {
+            //     errors |= ErrorCode.NOT_ENOUGH_LIQUIDITY;
+            // };
+            let err = new oracle_1.OracleErrors(errors);
+            let oraclePrice = new oracle_1.OraclePrice(price, confidence, currentTime);
+            return new oracle_1.OracleResult(oraclePrice, err);
+        });
+    }
+}
+exports.RaydiumCPMMOracle = RaydiumCPMMOracle;

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

@@ -0,0 +1,139 @@
+import Decimal from 'decimal.js';
+import { BN } from '@coral-xyz/anchor';
+import { Connection, PublicKey } from '@solana/web3.js';
+import { Oracle, OracleResult } from './oracle';
+declare enum Side {
+    Base = 0,
+    Quote = 1
+}
+declare enum Quote {
+    Usdc = 0,
+    Wsol = 1
+}
+declare class Observation {
+    timestamp: BN;
+    cum_t_0_price: BN;
+    cum_t_1_price: BN;
+    constructor(params: {
+        timestamp: BN;
+        cum_t_0_price: BN;
+        cum_t_1_price: BN;
+    });
+    static decode(data: Buffer, offset?: number): [Observation, number];
+    sub(other: Observation): Observation;
+    add(other: Observation): Observation;
+    get_weighted_observation(time: BN): Observation;
+    adjust_to_timestamp(target_timestamp: BN, observation_prev: Observation): Observation;
+    get_twap(side: Side): BN;
+}
+declare class ObservationState {
+    initialized: boolean;
+    observation_index: number;
+    pool_id: PublicKey;
+    observations: Observation[];
+    last_update_timestamp: BN;
+    padding: BN[];
+    constructor(params: {
+        initialized: boolean;
+        observation_index: number;
+        pool_id: PublicKey;
+        observations: Observation[];
+        last_update_timestamp: BN;
+        padding: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [ObservationState, number];
+}
+declare class PoolState {
+    amm_config: PublicKey;
+    pool_creator: PublicKey;
+    token_0_vault: PublicKey;
+    token_1_vault: PublicKey;
+    lp_mint: PublicKey;
+    token_0_mint: PublicKey;
+    token_1_mint: PublicKey;
+    token_0_program: PublicKey;
+    token_1_program: PublicKey;
+    observation_key: PublicKey;
+    auth_bump: number;
+    status: number;
+    lp_mint_decimals: number;
+    mint_0_decimals: number;
+    mint_1_decimals: number;
+    lp_supply: BN;
+    protocol_fees_token_0: BN;
+    protocol_fees_token_1: BN;
+    fund_fees_token_0: BN;
+    fund_fees_token_1: BN;
+    open_time: BN;
+    recent_epoch: BN;
+    creator_fee_on: number;
+    enable_creator_fee: boolean;
+    padding1: number[];
+    creator_fees_token_0: BN;
+    creator_fees_token_1: BN;
+    padding: BN[];
+    constructor(params: {
+        amm_config: PublicKey;
+        pool_creator: PublicKey;
+        token_0_vault: PublicKey;
+        token_1_vault: PublicKey;
+        lp_mint: PublicKey;
+        token_0_mint: PublicKey;
+        token_1_mint: PublicKey;
+        token_0_program: PublicKey;
+        token_1_program: PublicKey;
+        observation_key: PublicKey;
+        auth_bump: number;
+        status: number;
+        lp_mint_decimals: number;
+        mint_0_decimals: number;
+        mint_1_decimals: number;
+        lp_supply: BN;
+        protocol_fees_token_0: BN;
+        protocol_fees_token_1: BN;
+        fund_fees_token_0: BN;
+        fund_fees_token_1: BN;
+        open_time: BN;
+        recent_epoch: BN;
+        creator_fee_on: number;
+        enable_creator_fee: boolean;
+        padding1: number[];
+        creator_fees_token_0: BN;
+        creator_fees_token_1: BN;
+        padding: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [PoolState, number];
+}
+export declare class RaydiumCPMMOracle extends Oracle {
+    pool_id: PublicKey;
+    quote_token: Quote;
+    pool_state: PoolState;
+    side: Side;
+    observation_state: ObservationState;
+    private constructor();
+    static create(params: {
+        connection: Connection;
+        pool_id: PublicKey;
+        quote_token: Quote;
+        side: Side;
+        weight: number;
+        conf_thresh_bps?: number;
+        staleness_thresh?: number;
+        volatility_thresh?: number | Decimal;
+        min_liquidity?: number | Decimal;
+        staleness_conf_rate_bps?: number;
+    }): Promise<RaydiumCPMMOracle>;
+    set_side(side: Side): void;
+    static derive_observation_key(poolId: PublicKey): [PublicKey, number];
+    get_observation_at_index(index: number): Observation;
+    get_observation_at_timestamp(timestamp: BN, startIndex: number): Observation;
+    get_delta_observations(currentTime: BN): Observation[];
+    get_decimals(): number;
+    get_twap_30sec(current_time: BN): Decimal;
+    get_twap_2min(current_time: BN): Decimal;
+    get_twap_5min(current_time: BN): Decimal;
+    get_twap_20min(current_time: BN): Decimal;
+    get_confidence(current_time: BN): Decimal;
+    fetch(): Promise<OracleResult>;
+}
+export {};