@symmetry-hq/sdk 1.0.1

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

@@ -0,0 +1,9 @@
+import BN from "bn.js";
+export declare const U8_MAX: BN;
+export declare const U16_MAX: BN;
+export declare const U32_MAX: BN;
+export declare const U64_MAX: BN;
+export declare const U128_MAX: BN;
+export declare const HERMES_PUBLIC_ENDPOINT = "https://hermes.pyth.network";
+export declare const SOLANA_DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+export declare const SOLANA_MAINNET_ENDPOINT = "https://api.mainnet-beta.solana.com";

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

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_MAINNET_ENDPOINT = exports.SOLANA_DEVNET_ENDPOINT = exports.HERMES_PUBLIC_ENDPOINT = exports.U128_MAX = exports.U64_MAX = exports.U32_MAX = exports.U16_MAX = exports.U8_MAX = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+exports.U8_MAX = new bn_js_1.default(0xff);
+exports.U16_MAX = new bn_js_1.default(0xffff);
+exports.U32_MAX = new bn_js_1.default(0xffffffff);
+exports.U64_MAX = new bn_js_1.default(1).shln(64).sub(new bn_js_1.default(1));
+exports.U128_MAX = new bn_js_1.default(1).shln(128).sub(new bn_js_1.default(1));
+exports.HERMES_PUBLIC_ENDPOINT = "https://hermes.pyth.network";
+exports.SOLANA_DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+exports.SOLANA_MAINNET_ENDPOINT = "https://api.mainnet-beta.solana.com";

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

@@ -0,0 +1,24 @@
+import Decimal from 'decimal.js';
+import { AccountInfo, AddressLookupTableAccount } from '@solana/web3.js';
+import { Fraction } from '../../layouts/fraction';
+import { OracleAggregator, OracleData } from '../../layouts/oracle';
+export declare class OraclePrice {
+    price: Decimal;
+    conf: Decimal;
+    updateTime: number;
+    validated?: boolean;
+    constructor(price: Decimal, conf: Decimal, updateTime: number, validated?: boolean);
+    getMid(): Decimal;
+    getLow(): Decimal;
+    getHigh(): Decimal;
+}
+export declare class PriceAggregator {
+    numOracles: number;
+    oracles: OracleData[];
+    minConfBps: number;
+    confThreshBps: number;
+    minOraclesThresh: number;
+    confMultiplier: Fraction;
+    constructor(numOracles: number, oracles: OracleData[], minConfBps: number, confThreshBps: number, minOraclesThresh: number, confMultiplier: Fraction);
+    static fetch(oracleAggregator: OracleAggregator, lutAccounts: AddressLookupTableAccount[], accountInfoMap: Map<string, AccountInfo<Buffer> | null>, solPrice: OraclePrice, usdPrice: OraclePrice): OraclePrice;
+}

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

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceAggregator = exports.OraclePrice = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const constants_1 = require("../../constants");
+const fraction_1 = require("../../layouts/fraction");
+const oracle_1 = require("../../layouts/oracle");
+const constants_2 = require("./constants");
+const pythOracle_1 = require("./pythOracle");
+const raydiumClmmOracle_1 = require("./raydiumClmmOracle");
+const raydiumCpmmOracle_1 = require("./raydiumCpmmOracle");
+class OraclePrice {
+    constructor(price, conf, updateTime, validated) {
+        this.price = price;
+        this.conf = conf;
+        this.updateTime = updateTime;
+        let zero_Decimal = new decimal_js_1.default(0);
+        if (this.price.lt(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 < 0)
+            throw new Error("update time should be more than 0");
+        this.validated = validated;
+    }
+    getMid() {
+        return this.price;
+    }
+    getLow() {
+        return this.price.sub(this.conf);
+    }
+    getHigh() {
+        return this.price.add(this.conf);
+    }
+}
+exports.OraclePrice = OraclePrice;
+class PriceAggregator {
+    constructor(numOracles, oracles, minConfBps, confThreshBps, minOraclesThresh, confMultiplier) {
+        this.numOracles = numOracles;
+        this.oracles = oracles;
+        this.minConfBps = minConfBps;
+        this.confThreshBps = confThreshBps;
+        this.minOraclesThresh = minOraclesThresh;
+        this.confMultiplier = confMultiplier;
+        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 && this.minOraclesThresh <= constants_2.U32_MAX.toNumber()))
+            throw new Error(`Minimum number of oracles must be between 0 and ${constants_2.U32_MAX}`);
+    }
+    static fetch(oracleAggregator, lutAccounts, accountInfoMap, solPrice, usdPrice) {
+        let validated = true;
+        const agg = oracleAggregator;
+        const oracleResults = [];
+        for (let i = 0; i < agg.numOracles; i++) {
+            const oracleData = agg.oracles[i];
+            const settings = oracleData.oracleSettings;
+            let loadedAccounts = [];
+            for (let j = 0; j < settings.numRequiredAccounts; j++) {
+                const lutId = oracleData.accountsToLoadLutIds[j];
+                const lutIdx = oracleData.accountsToLoadLutIndices[j];
+                const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
+                const account = accountInfoMap.get(pubkey.toBase58());
+                // @ts-ignore
+                loadedAccounts.push(account);
+            }
+            if (settings.oracleType === oracle_1.OracleType.RaydiumClmm) {
+                // ensure tick arrays are appended in order: prev, current, next
+                const poolPubkey = lutAccounts[oracleData.accountsToLoadLutIds[0]].state.addresses[oracleData.accountsToLoadLutIndices[0]];
+                const poolAi = accountInfoMap.get(poolPubkey.toBase58());
+                if (poolAi) {
+                    const [poolState] = raydiumClmmOracle_1.PoolState.decode(poolAi.data, 8);
+                    const currStart = (0, raydiumClmmOracle_1.getTickArrayStartIndexByTick)(poolState.tickCurrent, poolState.tickSpacing);
+                    const prevStart = (0, raydiumClmmOracle_1.getNextTickArrayStartIndex)(currStart, poolState.tickSpacing, true);
+                    const nextStart = (0, raydiumClmmOracle_1.getNextTickArrayStartIndex)(currStart, poolState.tickSpacing, false);
+                    const poolId = poolPubkey;
+                    [prevStart, currStart, nextStart].forEach(start => {
+                        const pk = (0, raydiumClmmOracle_1.getPdaTickArrayAddress)(poolId, start);
+                        const ai = accountInfoMap.get(pk.toBase58());
+                        if (ai)
+                            loadedAccounts.push(ai);
+                    });
+                }
+            }
+            let result = (() => {
+                switch (settings.oracleType) {
+                    case oracle_1.OracleType.Pyth:
+                        return pythOracle_1.PythOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                    case oracle_1.OracleType.RaydiumClmm:
+                        return raydiumClmmOracle_1.RaydiumCLMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                    case oracle_1.OracleType.RaydiumCpmm:
+                        return raydiumCpmmOracle_1.RaydiumCPMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                    default:
+                        return new OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+                }
+            })();
+            // if oracle is required and price is 0, return 0 price, else skip oraclce
+            if (result.getMid().eq(new decimal_js_1.default(0))) {
+                if (settings.isRequired)
+                    validated = false;
+                continue;
+            }
+            if (!result.validated) {
+                if (settings.isRequired)
+                    validated = false;
+            }
+            oracleResults.push(result);
+        }
+        // check this
+        if (oracleResults.length < agg.minOraclesThresh)
+            validated = false;
+        let prices = [];
+        for (let i = 0; i < oracleResults.length; i++) {
+            const pr = oracleResults[i];
+            const weight = new decimal_js_1.default(agg.oracles[i].oracleSettings.weight);
+            prices.push({ price: pr.getMid(), weight: weight });
+            prices.push({ price: pr.getLow(), weight: weight });
+            prices.push({ price: pr.getHigh(), weight: weight });
+        }
+        const medianPrice = weightedPercentile(prices, 50);
+        const p25Price = weightedPercentile(prices, 25);
+        const p75Price = weightedPercentile(prices, 75);
+        let first = medianPrice.sub(p25Price);
+        let second = p75Price.sub(medianPrice);
+        let conf = first.gte(second) ? first : second;
+        // confidence should be strictly less than median price
+        conf = conf.lt(medianPrice) ? conf : medianPrice;
+        conf = conf.mul((0, fraction_1.fractionToDecimal)(agg.confMultiplier));
+        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS)).lt(new decimal_js_1.default(agg.minConfBps)))
+            conf = medianPrice.mul(new decimal_js_1.default(agg.minConfBps)).div(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS)).gt(new decimal_js_1.default(agg.confThreshBps)))
+            return new OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        const oldest = Math.min(...oracleResults.map(p => p.updateTime));
+        return new OraclePrice(medianPrice, conf, oldest, validated);
+    }
+}
+exports.PriceAggregator = PriceAggregator;
+function weightedPercentile(prices, percentile) {
+    if (percentile < 0 || percentile > 100) {
+        throw new Error("Percentile must be between 0 and 100");
+    }
+    // Sort by price ascending
+    prices.sort((a, b) => a.price.sub(b.price).toNumber());
+    // Edge cases
+    if (percentile === 0)
+        return prices[0].price;
+    if (percentile === 100)
+        return prices[prices.length - 1].price;
+    // Compute total weight
+    const totalWeight = prices.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)).div(new decimal_js_1.default(100));
+    // Cumulative sum
+    let cum = new decimal_js_1.default(0);
+    for (const { price, weight } of prices) {
+        cum = cum.add(weight);
+        if (cum.gte(thresh))
+            return price; // nearest-rank percentile
+    }
+    // fallback (should not happen, but safe)
+    return prices[prices.length - 1].price;
+}

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

@@ -0,0 +1,132 @@
+import BN from 'bn.js';
+import { HermesClient } from '@pythnetwork/hermes-client';
+import { AccountInfo, Connection, Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { OracleSettings } from '../../layouts/oracle';
+import { TxBatchData } from '../../txUtils';
+import { OraclePrice } from './oracle';
+export type VerificationLevel = {
+    kind: 'Partial';
+    numSignatures: number;
+} | {
+    kind: 'Full';
+};
+export declare function parseVerificationLevel(buf: Buffer, offset: number): {
+    level: VerificationLevel;
+    size: number;
+};
+export declare const TIP_ACCOUNTS: string[];
+export declare function getRandomTipAccount(): PublicKey;
+export declare function buildJitoTipInstruction(payer: PublicKey, lamports: number): TransactionInstruction;
+/**
+ * Derives the Pyth price feed account address
+ */
+export declare function getPythPriceFeedAccountAddress(shardId: number, priceFeedId: string | Buffer, pushOracleProgramId?: PublicKey): PublicKey;
+export interface InstructionWithSigners {
+    instruction: TransactionInstruction;
+    signers: Keypair[];
+    computeUnits?: number;
+}
+export interface PythUpdateResult {
+    postInstructions: InstructionWithSigners[];
+    closeInstructions: InstructionWithSigners[];
+    signers: Keypair[];
+    priceFeedAccounts: Map<string, PublicKey>;
+}
+export declare function parsePriceFeedMessage(message: Buffer): {
+    feedId: Buffer;
+    price: Buffer;
+    confidence: Buffer;
+    exponent: number;
+    publishTime: Buffer;
+    prevPublishTime: Buffer;
+    emaPrice: Buffer;
+    emaConf: Buffer;
+};
+/** parsing of accumulator update data (VAA + updates) */
+export declare function parseAccumulatorUpdateData(data: Buffer): {
+    vaa: Buffer;
+    updates: {
+        message: Buffer;
+        proof: number[][];
+    }[];
+};
+/**
+ * Get the size of a transaction that would contain the provided array of instructions
+ */
+export declare function getSizeOfTransaction(instructions: TransactionInstruction[], versionedTransaction?: boolean, addressLookupTable?: {
+    state: {
+        addresses: PublicKey[];
+    };
+}): number;
+/** Get the size of n in bytes when serialized as a CompressedU16 */
+export declare function getSizeOfCompressedU16(n: number): number;
+export interface InstructionBatch {
+    instructions: TransactionInstruction[];
+    signers: Keypair[];
+    computeUnits: number;
+}
+/**
+ * Fetch Pyth price accounts from RPC and extract feed IDs
+ */
+export declare function fetchFeedIdsFromAccounts(connection: Connection, priceAccounts: PublicKey[]): Promise<{
+    feedIds: string[];
+    feedIdToAccount: Map<string, PublicKey>;
+}>;
+export interface PythUpdateTxResult {
+    txBatchData: TxBatchData;
+    /** Keypairs that must sign their respective transactions before sending */
+    extraSigners: Map<number, Keypair[]>;
+}
+/**
+ * Build Pyth price feed update as TxBatchData compatible with SDK txUtils.
+ *
+ * TxBatchData.batches layout:
+ *   batch 0 (sequential): [createAccount + initEncodedVaa + writeVaa_part1]
+ *   batch 1 (sequential): [writeVaa_part2 + verifyEncodedVaa]
+ *   batch 2 (parallel):   [updateFeed_0], [updateFeed_1], ... [updateFeed_N-2]
+ *   batch 3 (sequential): [updateFeed_last + closeEncodedVaa]
+ *
+ * Transactions within each batch are sent in parallel by sendVersionedTxs.
+ * Batches are sent sequentially.
+ */
+export declare function buildPythPriceFeedUpdateIxs(payer: PublicKey, priceFeedIds: string[], defaultShardId?: number, hermesClient?: HermesClient): Promise<{
+    vaaCreateInitEncodeIxs: {
+        ixs: TransactionInstruction[];
+        signer: Keypair;
+    }[];
+    vaaWriteVerifyIxs: TransactionInstruction[][];
+    updateFeedIxs: TransactionInstruction[];
+    closeVaaIxs: TransactionInstruction[];
+}>;
+export declare class PriceFeedMessage {
+    feedId: Buffer;
+    price: BN;
+    conf: BN;
+    exponent: number;
+    publishTime: BN;
+    prevPublishTime: BN;
+    emaPrice: BN;
+    emaConf: BN;
+    constructor(params: {
+        feedId: Buffer;
+        price: BN;
+        conf: BN;
+        exponent: number;
+        publishTime: BN;
+        prevPublishTime: BN;
+        emaPrice: BN;
+        emaConf: BN;
+    });
+    static decode(buf: Buffer, offset?: number): [PriceFeedMessage, number];
+}
+export declare class PythState {
+    writeAuthority: PublicKey;
+    verificationLevel: VerificationLevel;
+    priceMessage: PriceFeedMessage;
+    postedSlot: BN;
+    constructor(writeAuthority: PublicKey, verificationLevel: VerificationLevel, priceMessage: PriceFeedMessage, postedSlot: BN);
+    static decode(buf: Buffer, offset?: number): [PythState, number];
+}
+export declare class PythOracle {
+    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], solPrice?: OraclePrice, usdPrice?: OraclePrice): OraclePrice;
+}