@symmetry-hq/temp-v3-sdk 0.0.1

package/src/states/oracles/oracle.ts

@@ -0,0 +1,260 @@
+import Decimal from 'decimal.js';
+
+import { BN } from '@coral-xyz/anchor';
+
+import { U32_MAX, U64_MAX } from './constants';
+
+export enum ErrorCode {
+    NONE = 0,
+    
+    // Basic Errors –––––––––––––––––––––
+    INVALID_PRICE               = 1 << 0,
+    TOO_VOLATILE                = 1 << 1,
+    TOO_UNCERTAIN               = 1 << 2,
+    STALE                       = 1 << 3,
+    NOT_ENOUGH_LIQUIDITY        = 1 << 4,
+    NOT_ENABLED                 = 1 << 5,
+    
+    // Aggregation errors –––––––––––––––
+    NOT_ENOUGH_ORACLES          = 1 << 6,
+    MISSING_REQUIRED_ORACLES    = 1 << 7,
+}
+
+export class OracleErrors extends Error{
+    code: ErrorCode;
+    
+    constructor(code: ErrorCode, message?: string ) {
+        super(message ?? ErrorCode[code]);
+        this.name = "OracleErrors";
+        this.code = code;
+    };
+    static NONE = new OracleErrors(ErrorCode.NONE);
+    static INVALID_PRICE = new OracleErrors(ErrorCode.INVALID_PRICE);
+    static TOO_VOLATILE = new OracleErrors(ErrorCode.TOO_VOLATILE);
+    static TOO_UNCERTAIN = new OracleErrors(ErrorCode.TOO_UNCERTAIN);
+    static STALE = new OracleErrors(ErrorCode.STALE);
+    static NOT_ENOUGH_LIQUIDITY = new OracleErrors(ErrorCode.NOT_ENOUGH_LIQUIDITY);
+    static NOT_ENABLED = new OracleErrors(ErrorCode.NOT_ENABLED);
+    static NOT_ENOUGH_ORACLES = new OracleErrors(ErrorCode.NOT_ENOUGH_ORACLES);
+    static MISSING_REQUIRED_ORACLES = new OracleErrors(ErrorCode.NOT_ENABLED); 
+}
+
+export class OraclePrice {
+    price: Decimal;
+    conf: Decimal;
+    updateTime: BN;
+    mid: Decimal;
+    low: Decimal;
+    high: Decimal;
+
+    constructor(price: Decimal, conf: Decimal, updateTime: BN){
+        this.price = new Decimal(price);
+        this.conf = new Decimal(conf);
+        this.updateTime = updateTime;
+        this.mid = this.price;
+        this.low = this.price.sub(this.conf);
+        this.high = this.price.add(this.conf);
+
+        let zero_Decimal = new Decimal(0);
+        if(this.price.lte(zero_Decimal)) throw new Error("price should be more than 0");
+        if(this.conf.lt(zero_Decimal)) throw new Error("confidence can't be negative");
+        if(this.updateTime.lte(0)) throw new Error("update time should be more than 0");
+    }
+}
+
+export class OracleResult {
+    price: OraclePrice | null;
+    error: OracleErrors = OracleErrors.NONE;
+    constructor(price: OraclePrice | null, error?: OracleErrors){
+        this.price = price;
+        this.error = error ?? OracleErrors.NONE;
+    }
+    ok(): boolean {
+        return this.error === OracleErrors.NONE;
+    }
+}
+
+export abstract class Oracle {
+    weight: number = 1;
+    confThreshBps: number = 1500;
+    stalenessThresh: number = 60;
+    volatilityThresh: Decimal = new Decimal(5);
+    minLiquidity: Decimal = new Decimal(0);
+    stalenessConfRateBps: number = 0;
+
+    constructor(weight: number, confThreshBps?: number, stalenessThresh?: number,
+                volatilityThresh?:  number | Decimal, minLiquidity?: number | Decimal,
+                stalenessConfRateBps?: number){
+        this.weight = weight;
+        this.confThreshBps = confThreshBps ?? 1500;
+        this.stalenessThresh = stalenessThresh ?? 60;
+        this.volatilityThresh = new Decimal(volatilityThresh ?? 5);
+        this.minLiquidity = new Decimal(minLiquidity ?? 0);
+        this.stalenessConfRateBps = stalenessConfRateBps ?? 0;
+
+        if(!(0 <= this.weight && new BN(this.weight).lte(U32_MAX)))
+            throw Error(`Weight must be between 0 and ${U32_MAX.toString()}`);
+        if(!(0 <= this.confThreshBps && this.confThreshBps < 10_000))
+            throw Error(`Confidence threshold must be between 0 and 10000`);
+        if(!(0 <= this.stalenessConfRateBps && new BN(this.stalenessConfRateBps).lt(U32_MAX)))
+            throw Error(`Staleness confidence rate must be between 0 and ${U32_MAX.toString()}`);
+        if(!(new Decimal(1).lte(this.volatilityThresh) && this.volatilityThresh.lte(new Decimal(U32_MAX.toString()))))
+            throw Error(`Volatility threshold must be between 1 and ${U32_MAX.toString()}`);
+        if(!(new Decimal(0).lte(this.minLiquidity) && this.minLiquidity.lte(new Decimal(U64_MAX.toString()))))
+            throw Error(`Minimum liquidity must be between 0 and ${U64_MAX.toString()}`);
+        if(!(0 <= this.stalenessThresh && this.stalenessThresh <= 10_000))
+            throw Error(`Staleness threshold must be between 0 and 10000`);
+
+    }
+    abstract fetch(): Promise<OracleResult>;
+
+}
+
+export class OracleAggregator{
+    oracles: Oracle[];
+    requiredOracles: Oracle[];
+    minConfBps: number = 0;
+    confThreshBps: number = 0;
+    minOraclesThresh: number = 0;
+
+    constructor(oracles: Oracle[], requiredOracles: Oracle[], minConfBps: number = 0, 
+                confThreshBps: number = 0, minOraclesThresh: number = 0){
+        this.oracles = oracles;
+        this.requiredOracles = requiredOracles;
+        this.minConfBps = minConfBps;
+        this.confThreshBps = confThreshBps;
+        this.minOraclesThresh = minOraclesThresh;
+
+        if(!(this.oracles.length > 0))
+            throw new Error(`At least one oracle is required`);
+        if(!(0 <= this.minConfBps && this.minConfBps < 10_000))
+            throw new Error(`Minimum confidence must be between 0 and 10000`);
+        if(!(0 <= this.confThreshBps && this.confThreshBps < 10_000))
+            throw new Error(`Confidence threshold must be between 0 and 10000`);
+        if(!(0 <= this.minOraclesThresh && new BN(this.minOraclesThresh).lte(U32_MAX)))
+            throw new Error(`Minimum number of oracles must be between 0 and ${U32_MAX}`);
+    }
+    async fetch(): Promise<OracleResult> {
+        console.log("Fetching price from oracle aggregator");
+        let prices: (OraclePrice | null)[] = Array(0);
+        let weights: Decimal[] = Array(0);
+
+        for(let i = 0; i< this.oracles.length; i++){
+            try {
+                let result = await this.oracles[i].fetch();
+                if(result.ok()){
+                    prices.push(result.price);
+                    weights.push(new Decimal(this.oracles[i].weight));
+                }
+                else {
+                    if(this.requiredOracles.includes(this.oracles[i])){
+                        return new OracleResult(null, OracleErrors.MISSING_REQUIRED_ORACLES);
+                    }
+                }
+            }
+            catch {
+                throw new Error("Unexpected error occured while fetching prices");
+            }
+        }
+        if(prices.length <= this.minOraclesThresh)
+            return new OracleResult(null, OracleErrors.NOT_ENOUGH_ORACLES);
+
+        let allPrices: (Decimal | null)[] = Array(0);
+        let allWeights: Decimal[] = Array(0);
+        let frac3: Decimal = new Decimal(3);
+        prices.map((price, i) => {
+            allPrices.push(price?.mid ?? null , price?.low ?? null , price?.high ?? null);
+            let w = weights[i].div(frac3);
+            allWeights.push(w,w,w);
+        });
+
+        let medianPrice = weightedMedian(allPrices, allWeights);
+        let p25Price = weightedPercentile(allPrices, allWeights, 25);
+        let p75Price = weightedPercentile(allPrices, allWeights, 75);
+
+        console.log("Median price: ", medianPrice.toString());
+        console.log("P25 price: ", p25Price.toString());
+        console.log("P75 price: ", p75Price.toString());
+
+        let first: Decimal = medianPrice.sub(p25Price);
+        let second: Decimal = p75Price.sub(medianPrice);
+        let conf = first.gte(second) ? first : second;
+        conf = conf.lte(medianPrice) ? conf : medianPrice;
+        if(conf.div(medianPrice).lt(this.minConfBps)) {
+            conf = medianPrice.mul(this.minConfBps)
+        };
+        if (conf.div(medianPrice).gt(this.confThreshBps)){
+            return new OracleResult(null, OracleErrors.TOO_UNCERTAIN);
+        }
+        const times = prices.filter((p): p is OraclePrice => p !== null) // drop nulls
+        .map(p => p.updateTime);
+
+        let oldestPriceTime: number = Math.min(...times);
+        return new OracleResult(new OraclePrice(medianPrice, conf, oldestPriceTime))
+
+    }
+}
+
+function weightedMedian(values: (Decimal | null)[], weights: Decimal[]): Decimal{
+    return weightedPercentile(values, weights=weights, 50);
+}
+
+function weightedPercentile(values: (Decimal | null)[], weights: Decimal[], percentile: number): Decimal {
+    if (percentile < 0 || percentile > 100) {
+        throw new Error("Percentile must be between 0 and 100");
+    }
+
+    if (!values || values.length === 0) {
+        throw new Error("Prices list is empty");
+    }
+
+    if (weights.length !== values.length) {
+        throw new Error("Weights and prices must have the same length");
+    }
+
+    if (weights.some((w) => w.lt(0))) {
+        throw new Error("Weights must be non-negative");
+    }
+
+    if (weights.every((w) => w.eq(0))) {
+        throw new Error("Weights must be non-zero");
+    }
+
+    // Filter out null prices along with their weights
+    const arr: { price: Decimal; weight: Decimal }[] = [];
+    for (let i = 0; i < values.length; i++) {
+        const p = values[i];
+        if (p !== null) {
+        arr.push({ price: p, weight: weights[i] });
+        }
+    }
+
+    if (arr.length === 0) {
+        throw new Error("All prices are null");
+    }
+
+    // Sort by price ascending
+    arr.sort((a, b) => a.price.sub(b.price).toNumber());
+
+    // Edge cases
+    if (percentile === 0) return arr[0].price;
+    if (percentile === 100) return arr[arr.length - 1].price;
+
+    // Compute total weight
+    const totalWeight = arr.reduce((sum, x) => sum.add(x.weight), new Decimal(0));
+
+    // Threshold = percentile% of total weight
+    const thresh = totalWeight.mul(new Decimal(percentile));
+
+    // Cumulative sum
+    let cum = new Decimal(0);
+    for (const { price, weight } of arr) {
+        cum = cum.add(weight);
+        if (cum.gte(thresh)) {
+        return price; // nearest-rank percentile
+        }
+    }
+
+    // fallback (should not happen, but safe)
+    return arr[arr.length - 1].price;
+}

package/src/states/oracles/pythOracle.ts

@@ -0,0 +1,270 @@
+import { Decimal } from 'decimal.js';
+
+import { AnchorProvider, BN, Provider, Wallet } from '@coral-xyz/anchor';
+import { HermesClient } from '@pythnetwork/hermes-client';
+import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver';
+import {
+    Connection, PublicKey, Signer, TransactionSignature, VersionedTransaction
+} from '@solana/web3.js';
+
+import { HERMES_PUBLIC_ENDPOINT, SOLANA_DEVNET_ENDPOINT } from './constants';
+import { ErrorCode, Oracle, OracleErrors, OraclePrice, OracleResult } from './oracle';
+
+interface PythState {
+    price: BN, // i64,
+    conf: BN, // u64,
+    expo: number, // i32,
+    publishTime: BN, // i64
+}; 
+
+
+export class PythOracle extends Oracle {
+    priceFeedAccount: PublicKey;
+    state: PythState;
+    connection: Connection;
+    priceClient: HermesClient;
+    priceFeedId: string = "";
+
+    private constructor(
+                priceFeedAccount: PublicKey,
+                connection: Connection,
+                priceClient: HermesClient,
+                state: PythState,
+                weight: number, 
+                confThreshBps?: number, 
+                stalenessThresh?: number, 
+                volatilityThresh?: Decimal, 
+                minLiquidity?: Decimal, 
+                stalenessConfRateBps?: number
+    ){
+        super(weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps);
+        this.priceFeedAccount = priceFeedAccount;
+        this.connection = connection;
+        this.priceClient = priceClient;
+        this.state = state;
+    };
+
+    static async create(
+        connection: Connection = new Connection(SOLANA_DEVNET_ENDPOINT),
+        priceFeedAccount: PublicKey,
+        weight: number,
+        priceClient?: HermesClient,
+        confThreshBps?: number, 
+        stalenessThresh?: number, 
+        volatilityThresh?: Decimal, 
+        minLiquidity?: Decimal, 
+        stalenessConfRateBps?: number
+    ): Promise<PythOracle> {
+
+        priceClient = priceClient ?? new HermesClient(HERMES_PUBLIC_ENDPOINT, {}); 
+        const priceAccountInfo = await connection.getAccountInfo(priceFeedAccount);
+        if(!priceAccountInfo) {
+            throw new Error(`Failed to fetch price account info for ${priceFeedAccount.toBase58()}`);
+        }
+        else {
+            let buffer: Buffer = priceAccountInfo!.data;
+            let offset = 8;
+            let writeAuthority = new PublicKey(buffer.slice(offset, offset+32));
+            offset += 32;
+            let {level, size} = parseVerificationLevel(buffer, offset);
+            offset += size;
+            let priceMessage = new PublicKey(buffer.slice(offset, offset+32));
+            offset += 32;
+            let price = new BN(buffer.slice(offset, offset+8), 'le').toString();
+            offset += 8;
+            let conf = new BN(buffer.slice(offset, offset+8), 'le').toString();
+            offset += 8;
+            let exp = new BN(buffer.slice(offset, offset + 4), 'le').fromTwos(32).toString();
+            offset += 4;
+            let publishTime = new BN(buffer.slice(offset, offset+8), 'le').fromTwos(64).toString();
+            offset += 8;
+            let state: PythState = {
+                price: new BN(price),
+                conf: new BN(conf),
+                expo: parseInt(exp),
+                publishTime: new BN(publishTime)
+            };
+            return new PythOracle(
+                // priceFeedId,
+                priceFeedAccount,
+                connection,
+                priceClient,
+                state, 
+                weight, 
+                confThreshBps, 
+                stalenessThresh, 
+                volatilityThresh, 
+                minLiquidity, 
+                stalenessConfRateBps
+            );
+        }
+    };
+
+    static async createWithId(
+        connection: Connection = new Connection(SOLANA_DEVNET_ENDPOINT),
+        priceFeedId: string,
+        wallet: Wallet,
+        weight: number,
+        priceClient?: HermesClient,
+        confThreshBps?: number, 
+        stalenessThresh?: number, 
+        volatilityThresh?: Decimal, 
+        minLiquidity?: Decimal, 
+        stalenessConfRateBps?: number
+    ): Promise<PythOracle> {
+
+        const pythSolanaReceiver = new PythSolanaReceiver({
+            connection,
+            wallet,
+        });
+        priceClient = priceClient ?? new HermesClient(HERMES_PUBLIC_ENDPOINT, {});
+        const priceAccount = pythSolanaReceiver.getPriceFeedAccountAddress(1, priceFeedId);
+        const priceAccountInfo = await connection.getAccountInfo(priceAccount);
+        if(!priceAccountInfo) {
+            throw new Error(`Failed to fetch price account info for ${priceAccount.toBase58()}`);
+        }
+        else {
+            let buffer: Buffer = priceAccountInfo!.data;
+            let offset = 8;
+            let writeAuthority = new PublicKey(buffer.slice(offset, offset+32));
+            offset += 32;
+            let {level, size} = parseVerificationLevel(buffer, offset);
+            offset += size;
+            let priceMessage = new PublicKey(buffer.slice(offset, offset+32));
+            offset += 32;
+            let price = new BN(buffer.slice(offset, offset+8), 'le').toString();
+            offset += 8;
+            let conf = new BN(buffer.slice(offset, offset+8), 'le').toString();
+            offset += 8;
+            let exp = new BN(buffer.slice(offset, offset + 4), 'le').fromTwos(32).toString();
+            offset += 4;
+            let publishTime = new BN(buffer.slice(offset, offset+8), 'le').fromTwos(64).toString();
+            offset += 8;
+            let state: PythState = {
+                price: new BN(price),
+                conf: new BN(conf),
+                expo: parseInt(exp),
+                publishTime: new BN(publishTime)
+            };
+            
+            
+
+            let pythOracle =  new PythOracle(
+                priceAccount,
+                connection,
+                priceClient,
+                state, 
+                weight, 
+                confThreshBps, 
+                stalenessThresh, 
+                volatilityThresh, 
+                minLiquidity, 
+                stalenessConfRateBps
+            );
+
+            pythOracle.setPriceFeedId(priceFeedId);
+
+            return pythOracle;
+        }
+    };
+
+    getConfidence(): Decimal {
+        return new Decimal(this.state.conf.toString()).mul(10**this.state.expo);
+    }
+
+    setPriceFeedId(priceFeedId: string) {
+        this.priceFeedId = priceFeedId;
+    } 
+    
+    async fetch(): Promise<OracleResult> {
+        const currentTime = new BN(Math.floor(Date.now() / 1000));
+        if(currentTime.sub(this.state.publishTime).gt(new BN(this.stalenessThresh))) {
+            this.state = await this.fetchPriceFromHermes(this.priceFeedId);
+        }
+
+        let errors = 0;
+        console.log(this.confThreshBps)
+        console.log(this.state.conf.toString());
+        let pr = new Decimal(this.state.price.toString()).mul(10**this.state.expo);
+        let cf = new Decimal(this.state.conf.toString()).mul(10**this.state.expo);
+        console.log(cf.div(pr).mul(10000));
+        if(this.getConfidence().div(this.state.price.toString()).mul(10000).gt(this.confThreshBps)) {
+            errors |= ErrorCode.TOO_UNCERTAIN;
+        }
+
+        let err = new OracleErrors(errors);
+        console.log(this.state.publishTime);
+        let oraclePrice = new OraclePrice(
+            new Decimal(this.state.price.toString()).mul(10**this.state.expo),
+            new Decimal(this.state.conf.toString()).mul(10**this.state.expo),
+            this.state.publishTime
+        )
+        return new OracleResult(oraclePrice, err);
+
+    }
+
+    async fetchPriceFromHermes(priceFeedId: string): Promise<PythState> {
+        const priceUpdate = await this.priceClient.getLatestPriceUpdates([priceFeedId], {encoding: "base64"});
+        if(priceUpdate && priceUpdate.parsed && priceUpdate.parsed.length > 0) {
+            const priceData = priceUpdate.parsed[0].price;
+            console.log(priceData.publishTime);
+            return {
+                price: new BN(priceData.price),
+                conf: new BN(priceData.conf),
+                expo: priceData.expo,
+                publishTime: new BN(priceData.publishTime)
+            };
+        } else {
+            throw new Error(`Failed to fetch price update from Hermes for ${priceFeedId}`);
+        }
+    }
+    /**
+    * Get parsed baskets by manager. Uses 10 paralel rpc calls so might get heavy. Should set feedDd before running this
+    * @param {number} shardId - between 0-2^64, default is 0
+    * @param {number} [computeUnitPrice] - compute unit price in microlamports, default is 100_000
+    */
+    async updateFeedTx(wallet: Wallet, shardId: number = 0, computeUnitPrice: number = 100000) {
+        if(!shardId) shardId = 0;
+        if(!computeUnitPrice) computeUnitPrice = 100000;
+        let priceUpdate = await this.priceClient.getLatestPriceUpdates([this.priceFeedId], {encoding: "base64"});
+        const pythSolanaReceiver = new PythSolanaReceiver({
+            connection: this.connection,
+            wallet: wallet,
+        });
+        const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({
+            // closeUpdateAccounts: false
+        });
+        await transactionBuilder.addUpdatePriceFeed(priceUpdate.binary.data, shardId);
+        let build = await transactionBuilder.buildVersionedTransactions({
+            computeUnitPriceMicroLamports: computeUnitPrice,
+        });
+
+        return build;
+    };
+
+    async sendUpdateTx(
+        provider: AnchorProvider,
+        updateFeedTx: {
+                tx: VersionedTransaction;
+                signers: Signer[];
+        }[] 
+    ): Promise<TransactionSignature[]>{
+
+        let txs = await provider.sendAll(updateFeedTx, { skipPreflight: true,  commitment: "confirmed"});
+        return txs;
+    }
+
+    
+}
+
+function parseVerificationLevel(buf: Buffer, offset: number): { level: string, size: number } {
+        const discr = buf.readUInt8(offset);
+        if (discr === 0) { // Partial
+            const numSignatures = buf.readUInt8(offset + 1);
+            return { level: `Partial(${numSignatures})`, size: 2 };
+        } else if (discr === 1) { // Full
+            return { level: "Full", size: 1 };
+        } else {
+            throw new Error(`Unknown verification level: ${discr}`);
+        }
+}