@symmetry-hq/temp-v3-sdk 0.0.1

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

@@ -0,0 +1,202 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythOracle = void 0;
+const decimal_js_1 = require("decimal.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const hermes_client_1 = require("@pythnetwork/hermes-client");
+const pyth_solana_receiver_1 = require("@pythnetwork/pyth-solana-receiver");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const oracle_1 = require("./oracle");
+;
+class PythOracle extends oracle_1.Oracle {
+    constructor(price_feed_account, connection, price_client, state, weight, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps) {
+        super(weight, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps);
+        this.price_feed_id = "";
+        this.price_feed_account = price_feed_account;
+        this.connection = connection;
+        this.price_client = price_client;
+        this.state = state;
+    }
+    ;
+    static create() {
+        return __awaiter(this, arguments, void 0, function* (connection = new web3_js_1.Connection(constants_1.SOLANA_DEVNET_ENDPOINT), price_feed_account, weight, price_client, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps) {
+            price_client = price_client !== null && price_client !== void 0 ? price_client : new hermes_client_1.HermesClient(constants_1.HERMES_PUBLIC_ENDPOINT, {});
+            const price_account_info = yield connection.getAccountInfo(price_feed_account);
+            if (!price_account_info) {
+                throw new Error(`Failed to fetch price account info for ${price_feed_account.toBase58()}`);
+            }
+            else {
+                let buffer = price_account_info.data;
+                let offset = 8;
+                let write_authority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let { level, size } = parseVerificationLevel(buffer, offset);
+                offset += size;
+                let price_message = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let price = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').toString();
+                offset += 8;
+                let conf = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').toString();
+                offset += 8;
+                let exp = new anchor_1.BN(buffer.slice(offset, offset + 4), 'le').fromTwos(32).toString();
+                offset += 4;
+                let publish_time = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').fromTwos(64).toString();
+                offset += 8;
+                let state = {
+                    price: new anchor_1.BN(price),
+                    conf: new anchor_1.BN(conf),
+                    expo: parseInt(exp),
+                    publishTime: new anchor_1.BN(publish_time)
+                };
+                return new PythOracle(
+                // price_feed_id,
+                price_feed_account, connection, price_client, state, weight, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps);
+            }
+        });
+    }
+    ;
+    static createWithId() {
+        return __awaiter(this, arguments, void 0, function* (connection = new web3_js_1.Connection(constants_1.SOLANA_DEVNET_ENDPOINT), price_feed_id, wallet, weight, price_client, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps) {
+            const pythSolanaReceiver = new pyth_solana_receiver_1.PythSolanaReceiver({
+                connection,
+                wallet,
+            });
+            price_client = price_client !== null && price_client !== void 0 ? price_client : new hermes_client_1.HermesClient(constants_1.HERMES_PUBLIC_ENDPOINT, {});
+            const price_account = pythSolanaReceiver.getPriceFeedAccountAddress(1, price_feed_id);
+            const price_account_info = yield connection.getAccountInfo(price_account);
+            if (!price_account_info) {
+                throw new Error(`Failed to fetch price account info for ${price_account.toBase58()}`);
+            }
+            else {
+                let buffer = price_account_info.data;
+                let offset = 8;
+                let write_authority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let { level, size } = parseVerificationLevel(buffer, offset);
+                offset += size;
+                let price_message = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let price = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').toString();
+                offset += 8;
+                let conf = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').toString();
+                offset += 8;
+                let exp = new anchor_1.BN(buffer.slice(offset, offset + 4), 'le').fromTwos(32).toString();
+                offset += 4;
+                let publish_time = new anchor_1.BN(buffer.slice(offset, offset + 8), 'le').fromTwos(64).toString();
+                offset += 8;
+                let state = {
+                    price: new anchor_1.BN(price),
+                    conf: new anchor_1.BN(conf),
+                    expo: parseInt(exp),
+                    publishTime: new anchor_1.BN(publish_time)
+                };
+                let pythOracle = new PythOracle(price_account, connection, price_client, state, weight, conf_thresh_bps, staleness_thresh, volatility_thresh, min_liquidity, staleness_conf_rate_bps);
+                pythOracle.set_price_feed_id(price_feed_id);
+                return pythOracle;
+            }
+        });
+    }
+    ;
+    get_confidence() {
+        return new decimal_js_1.Decimal(this.state.conf.toString()).mul(10 ** this.state.expo);
+    }
+    set_price_feed_id(price_feed_id) {
+        this.price_feed_id = price_feed_id;
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = new anchor_1.BN(Math.floor(Date.now() / 1000));
+            if (currentTime.sub(this.state.publishTime).gt(new anchor_1.BN(this.staleness_thresh))) {
+                this.state = yield this.fetchPriceFromHermes(this.price_feed_id);
+            }
+            let errors = 0;
+            console.log(this.conf_thresh_bps);
+            console.log(this.state.conf.toString());
+            let pr = new decimal_js_1.Decimal(this.state.price.toString()).mul(10 ** this.state.expo);
+            let cf = new decimal_js_1.Decimal(this.state.conf.toString()).mul(10 ** this.state.expo);
+            console.log(cf.div(pr).mul(10000));
+            if (this.get_confidence().div(this.state.price.toString()).mul(10000).gt(this.conf_thresh_bps)) {
+                errors |= oracle_1.ErrorCode.TOO_UNCERTAIN;
+            }
+            let err = new oracle_1.OracleErrors(errors);
+            console.log(this.state.publishTime);
+            let oracle_price = new oracle_1.OraclePrice(new decimal_js_1.Decimal(this.state.price.toString()).mul(10 ** this.state.expo), new decimal_js_1.Decimal(this.state.conf.toString()).mul(10 ** this.state.expo), this.state.publishTime);
+            return new oracle_1.OracleResult(oracle_price, err);
+        });
+    }
+    fetchPriceFromHermes(price_feed_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const priceUpdate = yield this.price_client.getLatestPriceUpdates([price_feed_id], { encoding: "base64" });
+            if (priceUpdate && priceUpdate.parsed && priceUpdate.parsed.length > 0) {
+                const priceData = priceUpdate.parsed[0].price;
+                console.log(priceData.publish_time);
+                return {
+                    price: new anchor_1.BN(priceData.price),
+                    conf: new anchor_1.BN(priceData.conf),
+                    expo: priceData.expo,
+                    publishTime: new anchor_1.BN(priceData.publish_time)
+                };
+            }
+            else {
+                throw new Error(`Failed to fetch price update from Hermes for ${price_feed_id}`);
+            }
+        });
+    }
+    /**
+    * Get parsed baskets by manager. Uses 10 paralel rpc calls so might get heavy. Should set feed_id 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
+    */
+    updateFeedTx(wallet_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet, shardId = 0, computeUnitPrice = 100000) {
+            if (!shardId)
+                shardId = 0;
+            if (!computeUnitPrice)
+                computeUnitPrice = 100000;
+            let price_update = yield this.price_client.getLatestPriceUpdates([this.price_feed_id], { encoding: "base64" });
+            const pythSolanaReceiver = new pyth_solana_receiver_1.PythSolanaReceiver({
+                connection: this.connection,
+                wallet: wallet,
+            });
+            const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({
+            // closeUpdateAccounts: false
+            });
+            yield transactionBuilder.addUpdatePriceFeed(price_update.binary.data, shardId);
+            let build = yield transactionBuilder.buildVersionedTransactions({
+                computeUnitPriceMicroLamports: computeUnitPrice,
+            });
+            return build;
+        });
+    }
+    ;
+    sendUpdateTx(provider, updateFeedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let txs = yield provider.sendAll(updateFeedTx, { skipPreflight: true, commitment: "confirmed" });
+            return txs;
+        });
+    }
+}
+exports.PythOracle = PythOracle;
+function parseVerificationLevel(buf, offset) {
+    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}`);
+    }
+}

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

@@ -0,0 +1,178 @@
+import Decimal from 'decimal.js';
+import { BN } from '@coral-xyz/anchor';
+import { Connection, PublicKey } from '@solana/web3.js';
+import { Oracle, OracleResult } from './oracle';
+declare class Observation {
+    blockTimestamp: BN;
+    tickCumulative: BN;
+    padding: BN[];
+    constructor(params: {
+        blockTimestamp: BN;
+        tickCumulative: BN;
+        padding: 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;
+}
+declare class ObservationState {
+    initialized: boolean;
+    recentEpoch: BN;
+    observationIndex: number;
+    poolId: PublicKey;
+    observations: Observation[];
+    padding: BN[];
+    constructor(params: {
+        initialized: boolean;
+        recentEpoch: BN;
+        observationIndex: number;
+        poolId: PublicKey;
+        observations: Observation[];
+        padding: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [ObservationState, number];
+}
+declare class RewardInfo {
+    rewardState: number;
+    openTime: BN;
+    endTime: BN;
+    lastUpdateTime: BN;
+    emissionsPerSecondX64: BN;
+    rewardTotalEmissioned: BN;
+    rewardClaimed: BN;
+    tokenMint: PublicKey;
+    tokenVault: PublicKey;
+    authority: PublicKey;
+    rewardGrowthGlobalX64: BN;
+    constructor(params: {
+        rewardState: number;
+        openTime: BN;
+        endTime: BN;
+        lastUpdateTime: BN;
+        emissionsPerSecondX64: BN;
+        rewardTotalEmissioned: BN;
+        rewardClaimed: BN;
+        tokenMint: PublicKey;
+        tokenVault: PublicKey;
+        authority: PublicKey;
+        rewardGrowthGlobalX64: BN;
+    });
+    static decode(data: Buffer, offset?: number): [RewardInfo, number];
+}
+declare class PoolState {
+    bump: number[];
+    ammConfig: PublicKey;
+    owner: PublicKey;
+    tokenMint0: PublicKey;
+    tokenMint1: PublicKey;
+    tokenVault0: PublicKey;
+    tokenVault1: PublicKey;
+    observationKey: PublicKey;
+    mintDecimals0: number;
+    mintDecimals1: number;
+    tickSpacing: number;
+    liquidity: BN;
+    sqrtPriceX64: BN;
+    tickCurrent: BN;
+    padding3: number;
+    padding4: number;
+    feeGrowthGlobal0X64: BN;
+    feeGrowthGlobal1X64: BN;
+    protocolFeesToken0: BN;
+    protocolFeesToken1: BN;
+    swapInAmountToken0: BN;
+    swapOutAmountToken1: BN;
+    swapInAmountToken1: BN;
+    swapOutAmountToken0: BN;
+    status: number;
+    padding: number[];
+    rewardInfos: RewardInfo[];
+    tickArrayBitmap: BN[];
+    totalFeesToken0: BN;
+    totalFeesClaimedToken0: BN;
+    totalFeesToken1: BN;
+    totalFeesClaimedToken1: BN;
+    fundFeesToken0: BN;
+    fundFeesToken1: BN;
+    openTime: BN;
+    recentEpoch: BN;
+    padding1: BN[];
+    padding2: BN[];
+    constructor(params: {
+        bump: number[];
+        ammConfig: PublicKey;
+        owner: PublicKey;
+        tokenMint0: PublicKey;
+        tokenMint1: PublicKey;
+        tokenVault0: PublicKey;
+        tokenVault1: PublicKey;
+        observationKey: PublicKey;
+        mintDecimals0: number;
+        mintDecimals1: number;
+        tickSpacing: BN;
+        liquidity: BN;
+        sqrtPriceX64: BN;
+        tickCurrent: BN;
+        padding3: number;
+        padding4: number;
+        feeGrowthGlobal0X64: BN;
+        feeGrowthGlobal1X64: BN;
+        protocolFeesToken0: BN;
+        protocolFeesToken1: BN;
+        swapInAmountToken0: BN;
+        swapOutAmountToken1: BN;
+        swapInAmountToken1: BN;
+        swapOutAmountToken0: BN;
+        status: number;
+        padding: number[];
+        rewardInfos: RewardInfo[];
+        tickArrayBitmap: BN[];
+        totalFeesToken0: BN;
+        totalFeesClaimedToken0: BN;
+        totalFeesToken1: BN;
+        totalFeesClaimedToken1: BN;
+        fundFeesToken0: BN;
+        fundFeesToken1: BN;
+        openTime: BN;
+        recentEpoch: BN;
+        padding1: BN[];
+        padding2: BN[];
+    });
+    static decode(data: Buffer, offset?: number): [PoolState, number];
+}
+export declare class RaydiumCLMMOracle extends Oracle {
+    poolId: PublicKey;
+    quoteToken: number;
+    poolState: PoolState;
+    observationState: ObservationState;
+    primarySeconds: number;
+    secondarySeconds: number;
+    private constructor();
+    static create(params: {
+        connection: Connection;
+        poolId: PublicKey;
+        quoteToken: number;
+        weight: number;
+        primarySeconds: number;
+        secondarySeconds: number;
+        confThreshBps?: number;
+        stalenessThresh?: number;
+        volatilityThresh?: number | Decimal;
+        minLiquidity?: number | Decimal;
+        stalenessConfRateBps?: number;
+    }): Promise<RaydiumCLMMOracle>;
+    static deriveObservationKey(poolId: PublicKey): [PublicKey, number];
+    getObservationAtIndex(index: number): Observation;
+    getObservationAtTimestamp(timestamp: BN, startIndex: number): Observation;
+    getDeltaObservations(currentTime: BN, primarySeconds: number, secondarySeconds: number): Observation[];
+    getSqrtPriceX64FromTick(tick: BN): BN;
+    sqrtPriceX64ToPrice(sqrtPriceX64: BN, decimalsA: number, decimalsB: number): Decimal;
+    x64ToDecimal(num: BN, decimalPlaces?: number): Decimal;
+    getTwapPrimary(currentTime: BN): Decimal;
+    getTwapSecondary(currentTime: BN): Decimal;
+    getConfidence(currentTime: BN): Decimal;
+    fetch(): Promise<OracleResult>;
+}
+export {};