@symmetry-hq/sdk 1.0.1

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

@@ -0,0 +1,609 @@
+"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.PythOracle = exports.PythState = exports.PriceFeedMessage = exports.TIP_ACCOUNTS = void 0;
+exports.parseVerificationLevel = parseVerificationLevel;
+exports.getRandomTipAccount = getRandomTipAccount;
+exports.buildJitoTipInstruction = buildJitoTipInstruction;
+exports.getPythPriceFeedAccountAddress = getPythPriceFeedAccountAddress;
+exports.parsePriceFeedMessage = parsePriceFeedMessage;
+exports.parseAccumulatorUpdateData = parseAccumulatorUpdateData;
+exports.getSizeOfTransaction = getSizeOfTransaction;
+exports.getSizeOfCompressedU16 = getSizeOfCompressedU16;
+exports.fetchFeedIdsFromAccounts = fetchFeedIdsFromAccounts;
+exports.buildPythPriceFeedUpdateIxs = buildPythPriceFeedUpdateIxs;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const hermes_client_1 = require("@pythnetwork/hermes-client");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../../constants");
+const constants_2 = require("./constants");
+const oracle_1 = require("./oracle");
+function parseVerificationLevel(buf, offset) {
+    const discr = buf.readUInt8(offset);
+    if (discr === 0) { // Partial
+        const numSignatures = buf.readUInt8(offset + 1);
+        return { level: { kind: 'Partial', numSignatures }, size: 2 };
+    }
+    else if (discr === 1) { // Full
+        return { level: { kind: 'Full' }, size: 1 };
+    }
+    else {
+        throw new Error(`Unknown verification level: ${discr}`);
+    }
+}
+// Pyth program IDs (mainnet)
+const DEFAULT_RECEIVER_PROGRAM_ID = new web3_js_1.PublicKey("rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ");
+const DEFAULT_PUSH_ORACLE_PROGRAM_ID = new web3_js_1.PublicKey("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
+const DEFAULT_WORMHOLE_PROGRAM_ID = new web3_js_1.PublicKey("HDwcJBJXjL9FpJ7UBsYBtaDjsBUhuLCUYoz3zr8SWWaQ");
+// Constants from Pyth SDK vaa.js
+const VAA_START = 46;
+const VAA_SPLIT_INDEX = 721;
+const VAA_SIGNATURE_SIZE = 66;
+const DEFAULT_REDUCED_GUARDIAN_SET_SIZE = 5;
+// Compute budget constants
+const VERIFY_ENCODED_VAA_COMPUTE_BUDGET = 350000;
+const UPDATE_PRICE_FEED_COMPUTE_BUDGET = 55000;
+const INIT_ENCODED_VAA_COMPUTE_BUDGET = 3000;
+const WRITE_ENCODED_VAA_COMPUTE_BUDGET = 3000;
+const CLOSE_ENCODED_VAA_COMPUTE_BUDGET = 30000;
+// Pre-computed discriminators
+const DISCRIMINATORS = {
+    // Wormhole instructions
+    initEncodedVaa: Buffer.from([209, 193, 173, 25, 91, 202, 181, 218]),
+    writeEncodedVaa: Buffer.from([199, 208, 110, 177, 150, 76, 118, 42]),
+    verifyEncodedVaaV1: Buffer.from([103, 56, 177, 229, 240, 103, 68, 73]),
+    closeEncodedVaa: Buffer.from([48, 221, 174, 198, 231, 7, 152, 38]),
+    // Pyth Push Oracle instructions  
+    updatePriceFeed: Buffer.from([28, 9, 93, 150, 86, 153, 188, 115]),
+};
+// Jito tip accounts (copied from pyth solana-utils)
+exports.TIP_ACCOUNTS = [
+    "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe",
+    "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
+    "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
+    "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
+    "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
+    "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
+    "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+    "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
+];
+function getRandomTipAccount() {
+    const idx = Math.floor(Math.random() * exports.TIP_ACCOUNTS.length);
+    return new web3_js_1.PublicKey(exports.TIP_ACCOUNTS[idx]);
+}
+function buildJitoTipInstruction(payer, lamports) {
+    return web3_js_1.SystemProgram.transfer({
+        fromPubkey: payer,
+        toPubkey: getRandomTipAccount(),
+        lamports,
+    });
+}
+/**
+ * Get a random treasury ID (0-255) - same as Pyth SDK's getRandomTreasuryId()
+ */
+function getRandomTreasuryId() {
+    return Math.floor(Math.random() * 256);
+}
+/**
+ * Derives the Pyth price feed account address
+ */
+function getPythPriceFeedAccountAddress(shardId, priceFeedId, pushOracleProgramId = DEFAULT_PUSH_ORACLE_PROGRAM_ID) {
+    let feedIdBuffer;
+    if (typeof priceFeedId === "string") {
+        const hexString = priceFeedId.startsWith("0x")
+            ? priceFeedId.slice(2)
+            : priceFeedId;
+        feedIdBuffer = Buffer.from(hexString, "hex");
+    }
+    else {
+        feedIdBuffer = priceFeedId;
+    }
+    if (feedIdBuffer.length !== 32) {
+        throw new Error("Feed ID should be 32 bytes long");
+    }
+    const shardBuffer = Buffer.alloc(2);
+    shardBuffer.writeUint16LE(shardId, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([shardBuffer, feedIdBuffer], pushOracleProgramId)[0];
+}
+/**
+ * Get Treasury PDA for Pyth Receiver
+ */
+function getTreasuryPda(treasuryId, programId = DEFAULT_RECEIVER_PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("treasury"), Buffer.from([treasuryId])], programId)[0];
+}
+/**
+ * Get Config PDA for Pyth Receiver
+ */
+function getConfigPda(programId = DEFAULT_RECEIVER_PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("config")], programId)[0];
+}
+/**
+ * Get Guardian Set PDA for Wormhole
+ */
+function getGuardianSetPda(guardianSetIndex, programId = DEFAULT_WORMHOLE_PROGRAM_ID) {
+    const indexBuffer = Buffer.alloc(4);
+    indexBuffer.writeUInt32BE(guardianSetIndex, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("GuardianSet"), indexBuffer], programId)[0];
+}
+/**
+ * Get guardian set index from VAA (offset 1, big-endian u32)
+ */
+function getGuardianSetIndex(vaa) {
+    return vaa.readUInt32BE(1);
+}
+/**
+ * Serialize Borsh Vec<u8> (4-byte LE length prefix + data)
+ */
+function serializeBorshBytes(data) {
+    const lenBuffer = Buffer.alloc(4);
+    lenBuffer.writeUInt32LE(data.length, 0);
+    return Buffer.concat([lenBuffer, data]);
+}
+/**
+ * Serialize Borsh Vec<[u8; 20]> for merkle proof
+ */
+function serializeBorshProof(proof) {
+    const lenBuffer = Buffer.alloc(4);
+    lenBuffer.writeUInt32LE(proof.length, 0);
+    return Buffer.concat([lenBuffer, ...proof]);
+}
+/**
+ * Build initEncodedVaa instruction
+ */
+function buildInitEncodedVaaInstruction(writeAuthority, encodedVaa, wormholeProgramId = DEFAULT_WORMHOLE_PROGRAM_ID) {
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: writeAuthority, isSigner: true, isWritable: false },
+            { pubkey: encodedVaa, isSigner: false, isWritable: true },
+        ],
+        programId: wormholeProgramId,
+        data: DISCRIMINATORS.initEncodedVaa,
+    });
+}
+/**
+ * Build writeEncodedVaa instruction
+ */
+function buildWriteEncodedVaaInstruction(writeAuthority, draftVaa, index, data, wormholeProgramId = DEFAULT_WORMHOLE_PROGRAM_ID) {
+    // Serialize args: index (u32 LE) + data (Borsh Vec<u8>)
+    const indexBuffer = Buffer.alloc(4);
+    indexBuffer.writeUInt32LE(index, 0);
+    const instructionData = Buffer.concat([
+        DISCRIMINATORS.writeEncodedVaa,
+        indexBuffer,
+        serializeBorshBytes(data),
+    ]);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: writeAuthority, isSigner: true, isWritable: false },
+            { pubkey: draftVaa, isSigner: false, isWritable: true },
+        ],
+        programId: wormholeProgramId,
+        data: instructionData,
+    });
+}
+/**
+ * Build verifyEncodedVaaV1 instruction
+ */
+function buildVerifyEncodedVaaV1Instruction(writeAuthority, draftVaa, guardianSetIndex, wormholeProgramId = DEFAULT_WORMHOLE_PROGRAM_ID) {
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: writeAuthority, isSigner: true, isWritable: false },
+            { pubkey: draftVaa, isSigner: false, isWritable: true },
+            { pubkey: getGuardianSetPda(guardianSetIndex, wormholeProgramId), isSigner: false, isWritable: false },
+        ],
+        programId: wormholeProgramId,
+        data: DISCRIMINATORS.verifyEncodedVaaV1,
+    });
+}
+/**
+ * Build closeEncodedVaa instruction
+ */
+function buildCloseEncodedVaaInstruction(writeAuthority, encodedVaa, wormholeProgramId = DEFAULT_WORMHOLE_PROGRAM_ID) {
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: writeAuthority, isSigner: true, isWritable: true },
+            { pubkey: encodedVaa, isSigner: false, isWritable: true },
+        ],
+        programId: wormholeProgramId,
+        data: DISCRIMINATORS.closeEncodedVaa,
+    });
+}
+/**
+ * Build updatePriceFeed instruction for Pyth Push Oracle
+ */
+function buildUpdatePriceFeedInstruction(params) {
+    const { payer, encodedVaa, priceFeedAccount, treasuryId, shardId, feedId, merklePriceUpdate, receiverProgramId = DEFAULT_RECEIVER_PROGRAM_ID, pushOracleProgramId = DEFAULT_PUSH_ORACLE_PROGRAM_ID, } = params;
+    const shardBuffer = Buffer.alloc(2);
+    shardBuffer.writeUint16LE(shardId, 0);
+    const data = Buffer.concat([
+        DISCRIMINATORS.updatePriceFeed,
+        // MerklePriceUpdate
+        serializeBorshBytes(merklePriceUpdate.message),
+        serializeBorshProof(merklePriceUpdate.proof),
+        // treasuryId (u8)
+        Buffer.from([treasuryId]),
+        // shardId (u16 LE)
+        shardBuffer,
+        // feedId ([u8; 32])
+        feedId,
+    ]);
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: receiverProgramId, isSigner: false, isWritable: false },
+        { pubkey: encodedVaa, isSigner: false, isWritable: false },
+        { pubkey: getConfigPda(receiverProgramId), isSigner: false, isWritable: false },
+        { pubkey: getTreasuryPda(treasuryId, receiverProgramId), isSigner: false, isWritable: true },
+        { pubkey: priceFeedAccount, isSigner: false, isWritable: true },
+        { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId: pushOracleProgramId,
+        data,
+    });
+}
+/**
+ * Convert proof from number[][] to Buffer[]
+ */
+function convertProof(proof) {
+    return proof.map(p => Buffer.from(p));
+}
+function parsePriceFeedMessage(message) {
+    let cursor = 0;
+    const variant = message.readUInt8(cursor);
+    cursor += 1;
+    if (variant !== 0)
+        throw new Error('Not a price feed message');
+    const feedId = message.subarray(cursor, cursor + 32);
+    cursor += 32;
+    const price = message.subarray(cursor, cursor + 8);
+    cursor += 8;
+    const confidence = message.subarray(cursor, cursor + 8);
+    cursor += 8;
+    const exponent = message.readInt32BE(cursor);
+    cursor += 4;
+    const publishTime = message.subarray(cursor, cursor + 8);
+    cursor += 8;
+    const prevPublishTime = message.subarray(cursor, cursor + 8);
+    cursor += 8;
+    const emaPrice = message.subarray(cursor, cursor + 8);
+    cursor += 8;
+    const emaConf = message.subarray(cursor, cursor + 8);
+    return { feedId, price, confidence, exponent, publishTime, prevPublishTime, emaPrice, emaConf };
+}
+/** parsing of accumulator update data (VAA + updates) */
+function parseAccumulatorUpdateData(data) {
+    const ACC_MAGIC = '504e4155';
+    if (data.toString('hex').slice(0, 8) !== ACC_MAGIC || data[4] !== 1 || data[5] !== 0) {
+        throw new Error('Invalid accumulator message');
+    }
+    let cursor = 6;
+    const trailingPayloadSize = data.readUInt8(cursor);
+    cursor += 1 + trailingPayloadSize;
+    cursor += 1;
+    const vaaSize = data.readUInt16BE(cursor);
+    cursor += 2;
+    const vaa = data.subarray(cursor, cursor + vaaSize);
+    cursor += vaaSize;
+    const numUpdates = data.readUInt8(cursor);
+    cursor += 1;
+    const updates = [];
+    const HASH_SIZE = 20;
+    for (let i = 0; i < numUpdates; i++) {
+        const messageSize = data.readUInt16BE(cursor);
+        cursor += 2;
+        const message = data.subarray(cursor, cursor + messageSize);
+        cursor += messageSize;
+        const numProofs = data.readUInt8(cursor);
+        cursor += 1;
+        const proof = [];
+        for (let j = 0; j < numProofs; j++) {
+            proof.push(Array.from(data.subarray(cursor, cursor + HASH_SIZE)));
+            cursor += HASH_SIZE;
+        }
+        updates.push({ message, proof });
+    }
+    if (cursor !== data.length)
+        throw new Error("Didn't reach end of message");
+    return { vaa, updates };
+}
+/**
+ * Get the size of a transaction that would contain the provided array of instructions
+ */
+function getSizeOfTransaction(instructions, versionedTransaction = true, addressLookupTable) {
+    const programs = new Set();
+    const signers = new Set();
+    let accounts = new Set();
+    instructions.map((ix) => {
+        programs.add(ix.programId.toBase58());
+        accounts.add(ix.programId.toBase58());
+        ix.keys.map((key) => {
+            if (key.isSigner) {
+                signers.add(key.pubkey.toBase58());
+            }
+            accounts.add(key.pubkey.toBase58());
+        });
+    });
+    const instruction_sizes = instructions
+        .map((ix) => 1 +
+        getSizeOfCompressedU16(ix.keys.length) +
+        ix.keys.length +
+        getSizeOfCompressedU16(ix.data.length) +
+        ix.data.length)
+        .reduce((a, b) => a + b, 0);
+    let numberOfAddressLookups = 0;
+    if (addressLookupTable) {
+        const lookupTableAddresses = addressLookupTable.state.addresses.map((address) => address.toBase58());
+        const totalNumberOfAccounts = accounts.size;
+        accounts = new Set([...accounts].filter((account) => !lookupTableAddresses.includes(account)));
+        accounts = new Set([...accounts, ...programs, ...signers]);
+        numberOfAddressLookups = totalNumberOfAccounts - accounts.size;
+    }
+    return (getSizeOfCompressedU16(signers.size) +
+        signers.size * 64 +
+        3 +
+        getSizeOfCompressedU16(accounts.size) +
+        32 * accounts.size +
+        32 +
+        getSizeOfCompressedU16(instructions.length) +
+        instruction_sizes +
+        (versionedTransaction ? 1 + getSizeOfCompressedU16(0) : 0) +
+        (versionedTransaction && addressLookupTable ? 32 : 0) +
+        (versionedTransaction && addressLookupTable ? 2 : 0) +
+        numberOfAddressLookups);
+}
+/** Get the size of n in bytes when serialized as a CompressedU16 */
+function getSizeOfCompressedU16(n) {
+    return 1 + Number(n >= 128) + Number(n >= 16384);
+}
+const ENCODED_VAA_RENT_EXEMPTION = 7836960;
+/**
+ * Fetch Pyth price accounts from RPC and extract feed IDs
+ */
+function fetchFeedIdsFromAccounts(connection, priceAccounts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const accountInfos = yield connection.getMultipleAccountsInfo(priceAccounts, "confirmed");
+        const feedIds = [];
+        const feedIdToAccount = new Map();
+        for (let i = 0; i < priceAccounts.length; i++) {
+            const ai = accountInfos[i];
+            if (!ai)
+                throw new Error(`Account ${priceAccounts[i].toBase58()} not found`);
+            const [state, _] = PythState.decode(ai.data, 8);
+            const feedIdHex = "0x" + state.priceMessage.feedId.toString("hex");
+            feedIds.push(feedIdHex);
+            feedIdToAccount.set(feedIdHex, priceAccounts[i]);
+        }
+        return { feedIds, feedIdToAccount };
+    });
+}
+/**
+ * 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.
+ */
+function buildPythPriceFeedUpdateIxs(payer, priceFeedIds, defaultShardId, hermesClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const client = hermesClient !== null && hermesClient !== void 0 ? hermesClient : new hermes_client_1.HermesClient(constants_2.HERMES_PUBLIC_ENDPOINT, {});
+        const shardId = defaultShardId !== null && defaultShardId !== void 0 ? defaultShardId : 0;
+        const priceUpdates = yield client.getLatestPriceUpdates(priceFeedIds, { encoding: "base64" });
+        if (!((_a = priceUpdates.binary) === null || _a === void 0 ? void 0 : _a.data) || priceUpdates.binary.data.length === 0) {
+            throw new Error("Failed to fetch price updates from Hermes");
+        }
+        const treasuryId = getRandomTreasuryId();
+        let allVaaCreateInitEncodeIxs = [];
+        let allVaaWriteVerifyIxs = [];
+        const allUpdateIxs = [];
+        const allCloseIxs = [];
+        for (const updateData of priceUpdates.binary.data) {
+            const accumulatorData = parseAccumulatorUpdateData(Buffer.from(updateData, "base64"));
+            const vaa = accumulatorData.vaa;
+            const encodedVaaKeypair = web3_js_1.Keypair.generate();
+            const encodedVaaSize = vaa.length + VAA_START;
+            const guardianSetIndex = getGuardianSetIndex(vaa);
+            let vaaCreateInitEncodeIxs = [];
+            let vaaWriteVerifyIxs = [];
+            // createAccount
+            vaaCreateInitEncodeIxs.push(web3_js_1.SystemProgram.createAccount({
+                fromPubkey: payer,
+                newAccountPubkey: encodedVaaKeypair.publicKey,
+                lamports: ENCODED_VAA_RENT_EXEMPTION,
+                space: encodedVaaSize,
+                programId: DEFAULT_WORMHOLE_PROGRAM_ID,
+            }));
+            // initEncodedVaa
+            vaaCreateInitEncodeIxs.push(buildInitEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey));
+            // writeEncodedVaa part 1
+            const firstPartEnd = Math.min(VAA_SPLIT_INDEX, vaa.length);
+            vaaCreateInitEncodeIxs.push(buildWriteEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey, 0, vaa.subarray(0, firstPartEnd)));
+            // writeEncodedVaa part 2 (if needed)
+            if (vaa.length > VAA_SPLIT_INDEX) {
+                vaaWriteVerifyIxs.push(buildWriteEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey, VAA_SPLIT_INDEX, vaa.subarray(VAA_SPLIT_INDEX)));
+            }
+            // verifyEncodedVaaV1
+            vaaWriteVerifyIxs.push(buildVerifyEncodedVaaV1Instruction(payer, encodedVaaKeypair.publicKey, guardianSetIndex));
+            // updateFeed per price update
+            for (const update of accumulatorData.updates) {
+                const parsedMessage = parsePriceFeedMessage(update.message);
+                const feedId = parsedMessage.feedId;
+                allUpdateIxs.push(buildUpdatePriceFeedInstruction({
+                    payer,
+                    encodedVaa: encodedVaaKeypair.publicKey,
+                    priceFeedAccount: getPythPriceFeedAccountAddress(shardId, feedId),
+                    treasuryId,
+                    shardId,
+                    feedId,
+                    merklePriceUpdate: {
+                        message: update.message,
+                        proof: convertProof(update.proof),
+                    },
+                }));
+            }
+            allVaaCreateInitEncodeIxs.push({
+                ixs: vaaCreateInitEncodeIxs,
+                signer: encodedVaaKeypair,
+            });
+            allVaaWriteVerifyIxs.push(vaaWriteVerifyIxs);
+            // closeEncodedVaa
+            allCloseIxs.push(buildCloseEncodedVaaInstruction(payer, encodedVaaKeypair.publicKey));
+        }
+        return {
+            vaaCreateInitEncodeIxs: allVaaCreateInitEncodeIxs,
+            vaaWriteVerifyIxs: allVaaWriteVerifyIxs,
+            updateFeedIxs: allUpdateIxs,
+            closeVaaIxs: allCloseIxs,
+        };
+    });
+}
+class PriceFeedMessage {
+    constructor(params) {
+        this.feedId = params.feedId;
+        this.price = params.price;
+        this.conf = params.conf;
+        this.exponent = params.exponent;
+        this.publishTime = params.publishTime;
+        this.prevPublishTime = params.prevPublishTime;
+        this.emaPrice = params.emaPrice;
+        this.emaConf = params.emaConf;
+    }
+    static decode(buf, offset = 0) {
+        let cursor = offset;
+        // feed_id: [u8;32]
+        const feedId = buf.subarray(cursor, cursor + 32);
+        cursor += 32;
+        // price: i64 (signed)
+        const price = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
+        cursor += 8;
+        // conf: u64 (unsigned)
+        const conf = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        // exponent: i32 (signed)
+        const exponent = new bn_js_1.default(buf.subarray(cursor, cursor + 4), "le").fromTwos(32).toNumber();
+        cursor += 4;
+        // publish_time: i64 (signed)
+        const publishTime = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
+        cursor += 8;
+        // prev_publish_time: i64 (signed)
+        const prevPublishTime = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
+        cursor += 8;
+        // ema_price: i64 (signed)
+        const emaPrice = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le").fromTwos(64);
+        cursor += 8;
+        // ema_conf: u64 (unsigned)
+        const emaConf = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        return [new PriceFeedMessage({
+                feedId,
+                price,
+                conf,
+                exponent,
+                publishTime,
+                prevPublishTime,
+                emaPrice,
+                emaConf
+            }), cursor];
+    }
+}
+exports.PriceFeedMessage = PriceFeedMessage;
+class PythState {
+    constructor(writeAuthority, verificationLevel, priceMessage, postedSlot) {
+        this.writeAuthority = writeAuthority;
+        this.verificationLevel = verificationLevel;
+        this.priceMessage = priceMessage;
+        this.postedSlot = postedSlot;
+    }
+    ;
+    static decode(buf, offset = 0) {
+        let cursor = offset;
+        // write_authority: Pubkey (32)
+        const writeAuthority = new web3_js_1.PublicKey(buf.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const { level, size } = parseVerificationLevel(buf, cursor);
+        cursor += size;
+        // price_message: PriceFeedMessage
+        const [priceMessage, next] = PriceFeedMessage.decode(buf, cursor);
+        cursor = next;
+        // posted_slot: u64
+        const postedSlot = new bn_js_1.default(buf.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        return [new PythState(writeAuthority, level, priceMessage, postedSlot), cursor];
+    }
+}
+exports.PythState = PythState;
+class PythOracle {
+    static fetch(oracleParams, accountInfos, solPrice, usdPrice) {
+        //@ts-ignore
+        let state = null;
+        try {
+            const stateAi = accountInfos[0];
+            const [parsedState, _] = PythState.decode(stateAi.data, 8);
+            state = parsedState;
+        }
+        catch (error) {
+            return new oracle_1.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        let pr = new decimal_js_1.default(state.priceMessage.price.toString()).mul(decimal_js_1.default.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
+        let ema = new decimal_js_1.default(state.priceMessage.emaPrice.toString()).mul(decimal_js_1.default.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
+        let cf = new decimal_js_1.default(state.priceMessage.conf.toString()).mul(decimal_js_1.default.pow(10, state.priceMessage.exponent - oracleParams.tokenDecimals));
+        const lastUpdateTimestamp = state.priceMessage.publishTime;
+        // Validate primary price is not zero
+        if (pr.lte(0)) {
+            return new oracle_1.OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
+        }
+        // === 1. Inflate confidence by staleness ===
+        // confidence = confidence * (1 + delta_t * stalenessConfRateBps / 10_000)
+        const now = new bn_js_1.default(Math.floor(Date.now() / 1000));
+        const deltaSeconds = Math.max(now.toNumber() - lastUpdateTimestamp.toNumber(), 0);
+        const deltaT = new decimal_js_1.default(deltaSeconds);
+        const deltaTBN = new bn_js_1.default(deltaSeconds);
+        const stalenessRate = new decimal_js_1.default(oracleParams.stalenessConfRateBps).div(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+        const inflateFactor = new decimal_js_1.default(1).add(deltaT.mul(stalenessRate));
+        cf = cf.mul(inflateFactor);
+        let validated = true;
+        // === 2. Validate confidence threshold ===
+        // confidence / price * 10_000 < confThreshBps
+        const confRatioBps = cf.div(pr).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+        if (confRatioBps.gt(new decimal_js_1.default(oracleParams.confThreshBps)))
+            validated = false;
+        // === 3. Validate staleness threshold ===
+        if (deltaTBN.gt(oracleParams.stalenessThresh))
+            validated = false;
+        // === 4. Validate volatility threshold using EMA and price ===
+        // max(ema, price) / min(ema, price) * 10_000 < volatilityThreshBps
+        const maxPrice = decimal_js_1.default.max(ema, pr);
+        const minPrice = decimal_js_1.default.min(ema, pr);
+        if (!minPrice.eq(0)) {
+            const volRatio = maxPrice.sub(minPrice).div(minPrice);
+            const volRatioBps = volRatio.mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+            if (volRatioBps.gt(new decimal_js_1.default(oracleParams.volatilityThreshBps))) {
+                validated = false;
+            }
+        }
+        else {
+            validated = false;
+        }
+        // we don't validate liquidity for Pyth
+        return new oracle_1.OraclePrice(pr, cf, parseInt(state.priceMessage.publishTime.toString()), validated);
+    }
+}
+exports.PythOracle = PythOracle;