@symmetry-hq/temp-v3-sdk 0.0.1

package/src/states/oracles/raydiumCpmmOracle.ts

@@ -0,0 +1,614 @@
+import Decimal from 'decimal.js';
+
+import { BN } from '@coral-xyz/anchor';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+import { ErrorCode, Oracle, OracleErrors, OraclePrice, OracleResult } from './oracle';
+
+const CPMM_PROGRAM_ID = new PublicKey("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+const DEV_CPMM_PROGRAM_ID = new PublicKey("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb");
+
+enum Side {
+    Base,
+    Quote,
+}
+
+enum Quote {
+    Usdc,
+    Wsol,
+}
+
+class Observation {
+    timestamp: BN; // u64
+    cumT0Price: BN; // u128
+    cumT1Price: BN; // u128
+    constructor(params: {timestamp: BN, cumT0Price: BN, cumT1Price: BN}){
+        this.timestamp = params.timestamp;
+        this.cumT0Price = params.cumT0Price;
+        this.cumT1Price = params.cumT1Price;
+    }
+    static decode(data: Buffer, offset = 0): [Observation, number] {
+        
+        const timestamp = new BN(
+            data.subarray(offset, offset+8),
+            "le"
+        );
+
+        const cumT0Price = new BN(
+            data.subarray(offset + 8, offset + 24),
+            'le'
+        );
+
+        const cumT1Price = new BN(
+            data.subarray(offset + 24, offset + 40),
+            'le'
+        );
+
+       
+
+        return [
+            new Observation({ 
+                timestamp, 
+                cumT0Price, 
+                cumT1Price }),
+            offset + 40
+        ];
+    }
+
+
+
+    sub(other: Observation): Observation {
+        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: Observation): Observation {
+        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: BN): Observation {
+        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: BN, observationPrev: Observation): Observation {
+        // 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);
+    }
+
+    public getTwap(side: Side): BN {
+        let cumPrice = new 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 {
+    initialized : boolean;
+    observationIndex: number; //u16
+    poolId: PublicKey;
+    observations: Observation[];
+    lastUpdateTimestamp: BN; // u64
+    padding: BN[]; // [u64; 3]
+
+    constructor(params: {
+        initialized: boolean,
+        observationIndex: number,
+        poolId: PublicKey,
+        observations: Observation[], 
+        lastUpdateTimestamp: BN, 
+        padding: BN[]
+    }){
+            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: Buffer, offset = 8): [ObservationState, number] {
+        let cursor = offset;
+
+        const initialized = data.readUInt8(cursor) !== 0;
+        cursor += 1;
+
+        const observationIndex = data.readUInt16LE(cursor);
+        cursor += 2;
+
+        const poolId = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const observations: Observation[] = [];
+        for (let i = 0; i < 100; i++) {
+            let obs: Observation;
+            [obs, cursor] = Observation.decode(data, cursor);
+            observations.push(obs);
+        }
+
+        const lastUpdateTimestamp = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const padding: BN[] = [];
+        for (let i = 0; i < 4; i++) {
+            padding.push(new BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+
+        return [
+            new ObservationState({
+                initialized, 
+                observationIndex,
+                poolId,
+                observations,
+                lastUpdateTimestamp,
+                padding
+            }),
+            cursor
+        ]
+    }
+}
+
+class PoolState {
+    ammConfig: PublicKey;
+    poolCreator: PublicKey;
+    token0Vault: PublicKey;
+    token1Vault: PublicKey;
+    lpMint: PublicKey;
+    token0Mint: PublicKey;
+    token1Mint: PublicKey;
+    token0Program: PublicKey;
+    token1Program: PublicKey;
+    observationKey: PublicKey;
+    authBump: number; // u8
+    status: number; // u8
+    lpMintDecimals: number; // u8
+    mint0Decimals: number; // u8
+    mint1Decimals: number; // u8
+    lpSupply: BN; // u64
+    protocolFeesToken0: BN; // u64
+    protocolFeesToken1: BN; // u64
+    fundFeesToken0: BN; // u64
+    fundFeesToken1: BN; // u64
+    openTime: BN; // u64
+    recentEpoch: BN; // u64
+    creatorFeeOn: number; //u8
+    enableCreatorFee: boolean;
+    padding1: number[]; // [u8; 6]
+    creatorFeesToken0: BN; // u64
+    creatorFeesToken1: BN; // u64
+    padding: BN[]; // [u64; 28]
+
+    constructor(
+        params: {
+            ammConfig: PublicKey;
+            poolCreator: PublicKey;
+            token0Vault: PublicKey;
+            token1Vault: PublicKey;
+            lpMint: PublicKey;
+            token0Mint: PublicKey;
+            token1Mint: PublicKey;
+            token0Program: PublicKey;
+            token1Program: PublicKey;
+            observationKey: PublicKey;
+            authBump: number; // u8
+            status: number; // u8
+            lpMintDecimals: number; // u8
+            mint0Decimals: number; // u8
+            mint1Decimals: number; // u8
+            lpSupply: BN; // u64
+            protocolFeesToken0: BN; // u64
+            protocolFeesToken1: BN; // u64
+            fundFeesToken0: BN; // u64
+            fundFeesToken1: BN; // u64
+            openTime: BN; // u64
+            recentEpoch: BN; // u64
+            creatorFeeOn: number; //u8
+            enableCreatorFee: boolean;
+            padding1: number[]; // [u8; 6]
+            creatorFeesToken0: BN; // u64
+            creatorFeesToken1: BN; // u64
+            padding: BN[]; // [u64; 28]
+    }){
+        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: Buffer, offset: number = 8): [PoolState, number] {
+        let cursor = offset;   
+
+        const ammConfig = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const poolCreator = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token0Vault = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token1Vault = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const lpMint = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token0Mint = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token1Mint = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token0Program = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const token1Program = new PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+
+        const observationKey = new 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(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const protocolFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const protocolFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const fundFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const fundFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const openTime = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const recentEpoch = new 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: number[] = [];
+        for (let i = 0; i < 6; i++) {
+            padding1.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+
+        const creatorFeesToken0 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const creatorFeesToken1 = new BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+
+        const padding: BN[] = [];
+        for (let i = 0; i < 28; i++) {
+            padding.push(new 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,
+        ];
+    }
+}
+
+export class RaydiumCPMMOracle extends Oracle{
+    poolId: PublicKey;
+    quoteToken: Quote;
+    poolState: PoolState;
+    side: Side;
+    observationState: ObservationState;
+
+    private constructor(params: {
+        poolId: PublicKey;
+        quoteToken: Quote;
+        poolState: PoolState;
+        side: Side;
+        observationState: ObservationState, 
+        weight: number,
+        confThreshBps?: number, 
+        stalenessThresh?: number,
+        volatilityThresh?: number | Decimal, 
+        minLiquidity?: number | Decimal,
+        stalenessConfRateBps?: number
+    }){
+        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 async create(params: {
+        connection: Connection,
+        poolId: PublicKey,
+        quoteToken: Quote,
+        side: Side,
+        weight: number,
+        confThreshBps?: number, 
+        stalenessThresh?: number,
+        volatilityThresh?: number | Decimal, 
+        minLiquidity?: number | Decimal,
+        stalenessConfRateBps?: number
+    }): Promise<RaydiumCPMMOracle> {
+        const { connection, poolId } = params;
+
+        // Fetch pooState
+        const poolAccountInfo = await connection.getAccountInfo(new 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 = await connection.getAccountInfo(new 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
+        });
+    }
+
+    public setSide(side: Side) {
+        this.side = side;
+    }
+
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number] {
+            const seeds = [
+                Buffer.from("observation"),
+                poolId.toBuffer(),
+            ];
+            return PublicKey.findProgramAddressSync(seeds, CPMM_PROGRAM_ID);
+    };
+    
+    getObservationAtIndex(index: number) {
+        return this.observationState.observations[index];
+    }
+
+    getObservationAtTimestamp(timestamp: BN, startIndex: number): Observation {
+            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: BN): Observation[] {
+    
+        const obsIndex = this.observationState.observationIndex;
+        const observationCurrent = this.getObservationAtTimestamp(currentTime, obsIndex);
+        const observation30s = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(30))), obsIndex);
+        const delta30s = observationCurrent.sub(observation30s);
+
+        const observation2min = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(120))), obsIndex);
+        const delta2min = observationCurrent.sub(observation2min);
+
+        const observation5min = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(300))), obsIndex);
+        const delta5min = observationCurrent.sub(observation5min);
+
+        const observation20min = this.getObservationAtTimestamp(new BN(currentTime.sub(new BN(1200))), obsIndex);
+        const delta20min = observationCurrent.sub(observation20min);
+
+        return [delta30s,delta2min, delta5min, delta20min];
+    };
+
+    getDecimals(): number {
+        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: BN): Decimal {
+        let observation = this.getDeltaObservations(currentTime)[0];
+        let twapScaled = new Decimal(observation.getTwap(this.side).toString()).div(2**32);
+        let twap = new Decimal(twapScaled.toString()).div(10**this.getDecimals());
+        return twap;
+    }
+
+    getTwap2min(currentTime: BN): Decimal {
+        let observation = this.getDeltaObservations(currentTime)[1];
+        let twapScaled = new Decimal(observation.getTwap(this.side).toString()).div(2**32);
+        let twap = new Decimal(twapScaled.toString()).div(10**this.getDecimals())
+        return twap;
+    }
+
+    getTwap5min(currentTime: BN): Decimal {
+        let observation = this.getDeltaObservations(currentTime)[2];
+        let twapScaled = new Decimal(observation.getTwap(this.side).toString()).div(2**32);
+        let twap = new Decimal(twapScaled.toString()).div(10**this.getDecimals())
+        return twap;
+    }
+
+    getTwap20min(currentTime: BN): Decimal {
+        let observation = this.getDeltaObservations(currentTime)[3];
+        let twapScaled = new Decimal(observation.getTwap(this.side).toString()).div(2**32);
+        let twap = new Decimal(twapScaled.toString()).div(10**this.getDecimals())
+        return twap;
+    }
+
+    getConfidence(currentTime: BN): Decimal {
+    
+        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;
+    }
+
+    async fetch(): Promise<OracleResult> {
+            const currentTime = new 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 OracleErrors(errors);
+            
+            let oraclePrice = new OraclePrice(price, confidence, currentTime);
+            return new OracleResult(
+                oraclePrice,
+                err
+            )
+        }
+
+}