@symmetry-hq/temp-v3-sdk 0.0.1

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

@@ -0,0 +1,237 @@
+"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.OracleAggregator = exports.Oracle = exports.OracleResult = exports.OraclePrice = exports.OracleErrors = exports.ErrorCode = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const anchor_1 = require("@coral-xyz/anchor");
+const constants_1 = require("./constants");
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["NONE"] = 0] = "NONE";
+    // Basic Errors –––––––––––––––––––––
+    ErrorCode[ErrorCode["INVALID_PRICE"] = 1] = "INVALID_PRICE";
+    ErrorCode[ErrorCode["TOO_VOLATILE"] = 2] = "TOO_VOLATILE";
+    ErrorCode[ErrorCode["TOO_UNCERTAIN"] = 4] = "TOO_UNCERTAIN";
+    ErrorCode[ErrorCode["STALE"] = 8] = "STALE";
+    ErrorCode[ErrorCode["NOT_ENOUGH_LIQUIDITY"] = 16] = "NOT_ENOUGH_LIQUIDITY";
+    ErrorCode[ErrorCode["NOT_ENABLED"] = 32] = "NOT_ENABLED";
+    // Aggregation errors –––––––––––––––
+    ErrorCode[ErrorCode["NOT_ENOUGH_ORACLES"] = 64] = "NOT_ENOUGH_ORACLES";
+    ErrorCode[ErrorCode["MISSING_REQUIRED_ORACLES"] = 128] = "MISSING_REQUIRED_ORACLES";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+class OracleErrors extends Error {
+    constructor(code, message) {
+        super(message !== null && message !== void 0 ? message : ErrorCode[code]);
+        this.name = "OracleErrors";
+        this.code = code;
+    }
+    ;
+}
+exports.OracleErrors = OracleErrors;
+OracleErrors.NONE = new OracleErrors(ErrorCode.NONE);
+OracleErrors.INVALID_PRICE = new OracleErrors(ErrorCode.INVALID_PRICE);
+OracleErrors.TOO_VOLATILE = new OracleErrors(ErrorCode.TOO_VOLATILE);
+OracleErrors.TOO_UNCERTAIN = new OracleErrors(ErrorCode.TOO_UNCERTAIN);
+OracleErrors.STALE = new OracleErrors(ErrorCode.STALE);
+OracleErrors.NOT_ENOUGH_LIQUIDITY = new OracleErrors(ErrorCode.NOT_ENOUGH_LIQUIDITY);
+OracleErrors.NOT_ENABLED = new OracleErrors(ErrorCode.NOT_ENABLED);
+OracleErrors.NOT_ENOUGH_ORACLES = new OracleErrors(ErrorCode.NOT_ENOUGH_ORACLES);
+OracleErrors.MISSING_REQUIRED_ORACLES = new OracleErrors(ErrorCode.NOT_ENABLED);
+class OraclePrice {
+    constructor(price, conf, updateTime) {
+        this.price = new decimal_js_1.default(price);
+        this.conf = new decimal_js_1.default(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_js_1.default(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");
+    }
+}
+exports.OraclePrice = OraclePrice;
+class OracleResult {
+    constructor(price, error) {
+        this.error = OracleErrors.NONE;
+        this.price = price;
+        this.error = error !== null && error !== void 0 ? error : OracleErrors.NONE;
+    }
+    ok() {
+        return this.error === OracleErrors.NONE;
+    }
+}
+exports.OracleResult = OracleResult;
+class Oracle {
+    constructor(weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps) {
+        this.weight = 1;
+        this.confThreshBps = 1500;
+        this.stalenessThresh = 60;
+        this.volatilityThresh = new decimal_js_1.default(5);
+        this.minLiquidity = new decimal_js_1.default(0);
+        this.stalenessConfRateBps = 0;
+        this.weight = weight;
+        this.confThreshBps = confThreshBps !== null && confThreshBps !== void 0 ? confThreshBps : 1500;
+        this.stalenessThresh = stalenessThresh !== null && stalenessThresh !== void 0 ? stalenessThresh : 60;
+        this.volatilityThresh = new decimal_js_1.default(volatilityThresh !== null && volatilityThresh !== void 0 ? volatilityThresh : 5);
+        this.minLiquidity = new decimal_js_1.default(minLiquidity !== null && minLiquidity !== void 0 ? minLiquidity : 0);
+        this.stalenessConfRateBps = stalenessConfRateBps !== null && stalenessConfRateBps !== void 0 ? stalenessConfRateBps : 0;
+        if (!(0 <= this.weight && new anchor_1.BN(this.weight).lte(constants_1.U32_MAX)))
+            throw Error(`Weight must be between 0 and ${constants_1.U32_MAX.toString()}`);
+        if (!(0 <= this.confThreshBps && this.confThreshBps < 10000))
+            throw Error(`Confidence threshold must be between 0 and 10000`);
+        if (!(0 <= this.stalenessConfRateBps && new anchor_1.BN(this.stalenessConfRateBps).lt(constants_1.U32_MAX)))
+            throw Error(`Staleness confidence rate must be between 0 and ${constants_1.U32_MAX.toString()}`);
+        if (!(new decimal_js_1.default(1).lte(this.volatilityThresh) && this.volatilityThresh.lte(new decimal_js_1.default(constants_1.U32_MAX.toString()))))
+            throw Error(`Volatility threshold must be between 1 and ${constants_1.U32_MAX.toString()}`);
+        if (!(new decimal_js_1.default(0).lte(this.minLiquidity) && this.minLiquidity.lte(new decimal_js_1.default(constants_1.U64_MAX.toString()))))
+            throw Error(`Minimum liquidity must be between 0 and ${constants_1.U64_MAX.toString()}`);
+        if (!(0 <= this.stalenessThresh && this.stalenessThresh <= 10000))
+            throw Error(`Staleness threshold must be between 0 and 10000`);
+    }
+}
+exports.Oracle = Oracle;
+class OracleAggregator {
+    constructor(oracles, requiredOracles, minConfBps = 0, confThreshBps = 0, minOraclesThresh = 0) {
+        this.minConfBps = 0;
+        this.confThreshBps = 0;
+        this.minOraclesThresh = 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 < 10000))
+            throw new Error(`Minimum confidence must be between 0 and 10000`);
+        if (!(0 <= this.confThreshBps && this.confThreshBps < 10000))
+            throw new Error(`Confidence threshold must be between 0 and 10000`);
+        if (!(0 <= this.minOraclesThresh && new anchor_1.BN(this.minOraclesThresh).lte(constants_1.U32_MAX)))
+            throw new Error(`Minimum number of oracles must be between 0 and ${constants_1.U32_MAX}`);
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Fetching price from oracle aggregator");
+            let prices = Array(0);
+            let weights = Array(0);
+            for (let i = 0; i < this.oracles.length; i++) {
+                try {
+                    let result = yield this.oracles[i].fetch();
+                    if (result.ok()) {
+                        prices.push(result.price);
+                        weights.push(new decimal_js_1.default(this.oracles[i].weight));
+                    }
+                    else {
+                        if (this.requiredOracles.includes(this.oracles[i])) {
+                            return new OracleResult(null, OracleErrors.MISSING_REQUIRED_ORACLES);
+                        }
+                    }
+                }
+                catch (_a) {
+                    throw new Error("Unexpected error occured while fetching prices");
+                }
+            }
+            if (prices.length <= this.minOraclesThresh)
+                return new OracleResult(null, OracleErrors.NOT_ENOUGH_ORACLES);
+            let allPrices = Array(0);
+            let allWeights = Array(0);
+            let frac3 = new decimal_js_1.default(3);
+            prices.map((price, i) => {
+                var _a, _b, _c;
+                allPrices.push((_a = price === null || price === void 0 ? void 0 : price.mid) !== null && _a !== void 0 ? _a : null, (_b = price === null || price === void 0 ? void 0 : price.low) !== null && _b !== void 0 ? _b : null, (_c = price === null || price === void 0 ? void 0 : price.high) !== null && _c !== void 0 ? _c : 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 = medianPrice.sub(p25Price);
+            let second = 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 !== null) // drop nulls
+                .map(p => p.updateTime);
+            let oldestPriceTime = Math.min(...times);
+            return new OracleResult(new OraclePrice(medianPrice, conf, oldestPriceTime));
+        });
+    }
+}
+exports.OracleAggregator = OracleAggregator;
+function weightedMedian(values, weights) {
+    return weightedPercentile(values, weights = weights, 50);
+}
+function weightedPercentile(values, weights, percentile) {
+    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 = [];
+    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_js_1.default(0));
+    // Threshold = percentile% of total weight
+    const thresh = totalWeight.mul(new decimal_js_1.default(percentile));
+    // Cumulative sum
+    let cum = new decimal_js_1.default(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/dist/src/states/oracles/pythOracle.d.ts

@@ -0,0 +1,39 @@
+import { Decimal } from 'decimal.js';
+import { AnchorProvider, BN, Wallet } from '@coral-xyz/anchor';
+import { HermesClient } from '@pythnetwork/hermes-client';
+import { Connection, PublicKey, Signer, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import { Oracle, OracleResult } from './oracle';
+interface PythState {
+    price: BN;
+    conf: BN;
+    expo: number;
+    publishTime: BN;
+}
+export declare class PythOracle extends Oracle {
+    priceFeedAccount: PublicKey;
+    state: PythState;
+    connection: Connection;
+    priceClient: HermesClient;
+    priceFeedId: string;
+    private constructor();
+    static create(connection: Connection | undefined, priceFeedAccount: PublicKey, weight: number, priceClient?: HermesClient, confThreshBps?: number, stalenessThresh?: number, volatilityThresh?: Decimal, minLiquidity?: Decimal, stalenessConfRateBps?: number): Promise<PythOracle>;
+    static createWithId(connection: Connection | undefined, priceFeedId: string, wallet: Wallet, weight: number, priceClient?: HermesClient, confThreshBps?: number, stalenessThresh?: number, volatilityThresh?: Decimal, minLiquidity?: Decimal, stalenessConfRateBps?: number): Promise<PythOracle>;
+    getConfidence(): Decimal;
+    setPriceFeedId(priceFeedId: string): void;
+    fetch(): Promise<OracleResult>;
+    fetchPriceFromHermes(priceFeedId: string): Promise<PythState>;
+    /**
+    * 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
+    */
+    updateFeedTx(wallet: Wallet, shardId?: number, computeUnitPrice?: number): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    sendUpdateTx(provider: AnchorProvider, updateFeedTx: {
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]): Promise<TransactionSignature[]>;
+}
+export {};

package/dist/src/states/oracles/pythOracle.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(priceFeedAccount, connection, priceClient, state, weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps) {
+        super(weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps);
+        this.priceFeedId = "";
+        this.priceFeedAccount = priceFeedAccount;
+        this.connection = connection;
+        this.priceClient = priceClient;
+        this.state = state;
+    }
+    ;
+    static create() {
+        return __awaiter(this, arguments, void 0, function* (connection = new web3_js_1.Connection(constants_1.SOLANA_DEVNET_ENDPOINT), priceFeedAccount, weight, priceClient, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps) {
+            priceClient = priceClient !== null && priceClient !== void 0 ? priceClient : new hermes_client_1.HermesClient(constants_1.HERMES_PUBLIC_ENDPOINT, {});
+            const priceAccountInfo = yield connection.getAccountInfo(priceFeedAccount);
+            if (!priceAccountInfo) {
+                throw new Error(`Failed to fetch price account info for ${priceFeedAccount.toBase58()}`);
+            }
+            else {
+                let buffer = priceAccountInfo.data;
+                let offset = 8;
+                let writeAuthority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let { level, size } = parseVerificationLevel(buffer, offset);
+                offset += size;
+                let priceMessage = 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 publishTime = 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(publishTime)
+                };
+                return new PythOracle(
+                // priceFeedId,
+                priceFeedAccount, connection, priceClient, state, weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps);
+            }
+        });
+    }
+    ;
+    static createWithId() {
+        return __awaiter(this, arguments, void 0, function* (connection = new web3_js_1.Connection(constants_1.SOLANA_DEVNET_ENDPOINT), priceFeedId, wallet, weight, priceClient, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps) {
+            const pythSolanaReceiver = new pyth_solana_receiver_1.PythSolanaReceiver({
+                connection,
+                wallet,
+            });
+            priceClient = priceClient !== null && priceClient !== void 0 ? priceClient : new hermes_client_1.HermesClient(constants_1.HERMES_PUBLIC_ENDPOINT, {});
+            const priceAccount = pythSolanaReceiver.getPriceFeedAccountAddress(1, priceFeedId);
+            const priceAccountInfo = yield connection.getAccountInfo(priceAccount);
+            if (!priceAccountInfo) {
+                throw new Error(`Failed to fetch price account info for ${priceAccount.toBase58()}`);
+            }
+            else {
+                let buffer = priceAccountInfo.data;
+                let offset = 8;
+                let writeAuthority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+                offset += 32;
+                let { level, size } = parseVerificationLevel(buffer, offset);
+                offset += size;
+                let priceMessage = 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 publishTime = 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(publishTime)
+                };
+                let pythOracle = new PythOracle(priceAccount, connection, priceClient, state, weight, confThreshBps, stalenessThresh, volatilityThresh, minLiquidity, stalenessConfRateBps);
+                pythOracle.setPriceFeedId(priceFeedId);
+                return pythOracle;
+            }
+        });
+    }
+    ;
+    getConfidence() {
+        return new decimal_js_1.Decimal(this.state.conf.toString()).mul(10 ** this.state.expo);
+    }
+    setPriceFeedId(priceFeedId) {
+        this.priceFeedId = priceFeedId;
+    }
+    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.stalenessThresh))) {
+                this.state = yield this.fetchPriceFromHermes(this.priceFeedId);
+            }
+            let errors = 0;
+            console.log(this.confThreshBps);
+            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.getConfidence().div(this.state.price.toString()).mul(10000).gt(this.confThreshBps)) {
+                errors |= oracle_1.ErrorCode.TOO_UNCERTAIN;
+            }
+            let err = new oracle_1.OracleErrors(errors);
+            console.log(this.state.publishTime);
+            let oraclePrice = 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(oraclePrice, err);
+        });
+    }
+    fetchPriceFromHermes(priceFeedId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const priceUpdate = yield 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 anchor_1.BN(priceData.price),
+                    conf: new anchor_1.BN(priceData.conf),
+                    expo: priceData.expo,
+                    publishTime: new anchor_1.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
+    */
+    updateFeedTx(wallet_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet, shardId = 0, computeUnitPrice = 100000) {
+            if (!shardId)
+                shardId = 0;
+            if (!computeUnitPrice)
+                computeUnitPrice = 100000;
+            let priceUpdate = yield this.priceClient.getLatestPriceUpdates([this.priceFeedId], { encoding: "base64" });
+            const pythSolanaReceiver = new pyth_solana_receiver_1.PythSolanaReceiver({
+                connection: this.connection,
+                wallet: wallet,
+            });
+            const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({
+            // closeUpdateAccounts: false
+            });
+            yield transactionBuilder.addUpdatePriceFeed(priceUpdate.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/pyth_oracle.d.ts

@@ -0,0 +1,39 @@
+import { Decimal } from 'decimal.js';
+import { AnchorProvider, BN, Wallet } from '@coral-xyz/anchor';
+import { HermesClient } from '@pythnetwork/hermes-client';
+import { Connection, PublicKey, Signer, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import { Oracle, OracleResult } from './oracle';
+interface PythState {
+    price: BN;
+    conf: BN;
+    expo: number;
+    publishTime: BN;
+}
+export declare class PythOracle extends Oracle {
+    price_feed_account: PublicKey;
+    state: PythState;
+    connection: Connection;
+    price_client: HermesClient;
+    price_feed_id: string;
+    private constructor();
+    static create(connection: Connection | undefined, price_feed_account: PublicKey, weight: number, price_client?: HermesClient, conf_thresh_bps?: number, staleness_thresh?: number, volatility_thresh?: Decimal, min_liquidity?: Decimal, staleness_conf_rate_bps?: number): Promise<PythOracle>;
+    static createWithId(connection: Connection | undefined, price_feed_id: string, wallet: Wallet, weight: number, price_client?: HermesClient, conf_thresh_bps?: number, staleness_thresh?: number, volatility_thresh?: Decimal, min_liquidity?: Decimal, staleness_conf_rate_bps?: number): Promise<PythOracle>;
+    get_confidence(): Decimal;
+    set_price_feed_id(price_feed_id: string): void;
+    fetch(): Promise<OracleResult>;
+    fetchPriceFromHermes(price_feed_id: string): Promise<PythState>;
+    /**
+    * 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: Wallet, shardId?: number, computeUnitPrice?: number): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    sendUpdateTx(provider: AnchorProvider, updateFeedTx: {
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]): Promise<TransactionSignature[]>;
+}
+export {};