@exponent-labs/exponent-fetcher 0.1.6 → 0.1.8

package/build/exponentFetcher.js

@@ -3,18 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchSolsticeRedemptionRate = exports.fetchSanctumIndex = exports.fetchAdrenaIndex = exports.fetchMeteoraIndex = exports.fetchFragmetricSupportedTokenIndex = exports.fetchKaminoVaultIndex = exports.fetchJupiterLendIndex = exports.fetchFragmetricIndex = exports.fetchGenericSyMetaIndex = exports.fetchPyth = exports.fetchJupiterPerpsIndex = exports.fetchJitoRestaking = exports.fetchPerenaStablePoolData = exports.fetchSplStakePoolIndex = exports.deserializeEmission = exports.serializeEmission = exports.fetchAllKaminoObligationsByKaminoReserve = exports.fetchKaminoReserve = exports.ExponentFetcher = exports.MyWallet = exports.deserializeAnchorizedPNumFromJson = exports.serializeAnchorizedPNumFromJson = void 0;
+exports.fetchOreExchangeRate = exports.fetchReflectRedemptionRate = exports.fetchSolsticeRedemptionRate = exports.fetchSanctumIndex = exports.fetchAdrenaIndex = exports.fetchMeteoraIndex = exports.fetchFragmetricSupportedTokenIndex = exports.fetchKaminoVaultIndex = exports.fetchJupiterLendIndex = exports.fetchFragmetricIndex = exports.fetchGenericSyMetaIndex = exports.fetchPyth = exports.fetchJupiterPerpsIndex = exports.fetchJitoRestaking = exports.fetchPerenaStablePoolData = exports.fetchSplStakePoolIndex = exports.deserializeEmission = exports.serializeEmission = exports.fetchAllKaminoObligationsByKaminoReserve = exports.fetchKaminoReserve = exports.deserializeYtPosition = exports.deserializeLpPosition = exports.deserializeMarketThreeTicks = exports.ExponentFetcher = exports.MyWallet = exports.deserializeAnchorizedPNumFromJson = exports.serializeAnchorizedPNumFromJson = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const anchor_2 = require("@coral-xyz/anchor");
 const spl_stake_pool_1 = require("@solana/spl-stake-pool");
 const spl_token_1 = require("@solana/spl-token");
-const spl_token_2 = require("@solana/spl-token");
+const bs58_1 = __importDefault(require("bs58"));
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const exponent_clmm_idl_1 = require("@exponent-labs/exponent-clmm-idl");
 const exponent_idl_1 = require("@exponent-labs/exponent-idl");
+const exponent_orderbook_idl_1 = require("@exponent-labs/exponent-orderbook-idl");
 const exponent_types_1 = require("@exponent-labs/exponent-types");
-const fragmetric_idl_1 = require("@exponent-labs/fragmetric-idl");
-const jupiter_lend_idl_1 = require("@exponent-labs/jupiter-lend-idl");
-const kamino_vault_idl_1 = require("@exponent-labs/kamino-vault-idl");
+const exponent_types_2 = require("@exponent-labs/exponent-types");
 const generic_sy_idl_1 = require("@exponent-labs/generic-sy-idl");
 const jito_restaking_sy_idl_1 = require("@exponent-labs/jito-restaking-sy-idl");
 const jito_restaking_sy_idl_2 = require("@exponent-labs/jito-restaking-sy-idl");
@@ -22,22 +22,31 @@ const kamino_reserve_deserializer_1 = require("@exponent-labs/kamino-reserve-des
 const kamino_reserve_deserializer_2 = require("@exponent-labs/kamino-reserve-deserializer");
 const kamino_sy_idl_1 = require("@exponent-labs/kamino-sy-idl");
 const kamino_sy_idl_2 = require("@exponent-labs/kamino-sy-idl");
+const kamino_vault_idl_1 = require("@exponent-labs/kamino-vault-idl");
 const marginfi_sy_idl_1 = require("@exponent-labs/marginfi-sy-idl");
 const meteora_idl_1 = require("@exponent-labs/meteora-idl");
 const perena_sy_idl_1 = require("@exponent-labs/perena-sy-idl");
 const perena_sy_idl_2 = require("@exponent-labs/perena-sy-idl");
 const precise_number_1 = require("@exponent-labs/precise-number");
-const sanctum_idl_1 = require("@exponent-labs/sanctum-idl");
-const adrena_idl_1 = require("@exponent-labs/adrena-idl");
-const solstice_idl_1 = require("@exponent-labs/solstice-idl");
+const adrena_1 = require("./utils/adrena");
+const fragmetric_1 = require("./utils/fragmetric");
+const jito_1 = require("./utils/jito");
+const jupiter_1 = require("./utils/jupiter");
 const meteora_1 = require("./utils/meteora");
-// Decode Jupiter Perps pool accounts via helper using Anchor 0.29.0
-const jupiter_perps_idl_1 = require("@exponent-labs/jupiter-perps-idl");
+const ore_1 = require("./utils/ore");
+const perena_1 = require("./utils/perena");
+const sanctum_1 = require("./utils/sanctum");
+const solstice_1 = require("./utils/solstice");
 function serializeAnchorizedPNumFromJson(pnum) {
     const serializedArray = pnum[0].map((bn) => bn.toString());
     return { 0: serializedArray };
 }
 exports.serializeAnchorizedPNumFromJson = serializeAnchorizedPNumFromJson;
+function readU128LE(buf, offset) {
+    const lo = buf.readBigUInt64LE(offset);
+    const hi = buf.readBigUInt64LE(offset + 8);
+    return (hi << 64n) + lo;
+}
 function deserializeAnchorizedPNumFromJson(serialized) {
     const bnArray = serialized[0].map((str) => new anchor_1.BN(str));
     return { 0: bnArray };
@@ -81,6 +90,8 @@ class ExponentFetcher {
     jitoRestakingSyProgram;
     perenaSyProgram;
     genericStandardProgram;
+    exponentClmmProgram;
+    orderbookProgram;
     connection;
     coreProgramId;
     marginfiSyProgramId;
@@ -105,6 +116,8 @@ class ExponentFetcher {
         this.jitoRestakingSyProgram = new anchor_1.Program(jito_restaking_sy_idl_2.IDL, provider);
         this.perenaSyProgram = new anchor_1.Program(perena_sy_idl_2.IDL, provider);
         this.genericStandardProgram = new anchor_1.Program(generic_sy_idl_1.IDL, provider);
+        this.exponentClmmProgram = new anchor_1.Program(exponent_clmm_idl_1.IDL, provider);
+        this.orderbookProgram = new anchor_1.Program(exponent_orderbook_idl_1.IDL, provider);
     }
     async fetchVault(address) {
         try {
@@ -128,6 +141,28 @@ class ExponentFetcher {
             throw e;
         }
     }
+    async fetchOrderbook(address) {
+        try {
+            const o = (await this.connection.getAccountInfo(address)).data;
+            return deserializeOrderbook(o);
+        }
+        catch (e) {
+            console.error(`Error fetching orderbook ${address.toBase58()}`);
+            console.error(e);
+            throw e;
+        }
+    }
+    async fetchOrderbookCpiAccounts(address) {
+        try {
+            const orderbookCpiAccounts = await this.orderbookProgram.account.cpiAccountsOrderbook.fetch(address);
+            return orderbookCpiAccounts;
+        }
+        catch (e) {
+            console.error(`Error fetching orderbook ${address.toBase58()}`);
+            console.error(e);
+            throw e;
+        }
+    }
     async fetchMarginfiSyMeta(address) {
         const x = await this.marginfiSyProgram.account.syMeta.fetch(address);
         return deserializeMarginfiSyMeta(x);
@@ -200,10 +235,59 @@ class ExponentFetcher {
         const x = await this.program.account.lpPosition.fetch(address);
         return deserializeLpPosition(x);
     }
+    async fetchLpPositionCLMM(address) {
+        try {
+            const raw = await this.exponentClmmProgram.account.lpPosition.fetch(address);
+            const v = {
+                owner: raw.owner,
+                market: raw.market,
+                feeInsideLastPt: raw.feeInsideLastPt,
+                feeInsideLastSy: raw.feeInsideLastSy,
+                lpBalance: raw.lpBalance,
+                tokensOwedSy: raw.tokensOwedSy,
+                tokensOwedPt: raw.tokensOwedPt,
+                lowerTickIdx: raw.lowerTickIdx,
+                upperTickIdx: raw.upperTickIdx,
+                farms: {
+                    trackers: raw.farms.trackers.map((t) => ({
+                        staged: t.staged,
+                        lastSeenIndex: t.lastSeenIndex,
+                    })),
+                },
+                shareTrackers: {
+                    trackers: raw.shareTrackers.trackers.map((tracker) => ({
+                        tickIdx: tracker.tickIdx,
+                        rightTickIdx: tracker.rightTickIdx,
+                        splitEpoch: tracker.splitEpoch,
+                        lpShare: tracker.lpShare,
+                        emissions: {
+                            trackers: tracker.emissions.trackers.map((e) => ({
+                                staged: e.staged,
+                                lastSeenIndex: e.lastSeenIndex,
+                            })),
+                        },
+                    })),
+                },
+            };
+            return deserializeLpPositionCLMM(v);
+        }
+        catch (e) {
+            console.error(`Error fetching clmm lp position ${address.toBase58()}`);
+            console.error(e);
+            throw e;
+        }
+    }
     async fetchYtPosition(address) {
         const x = await this.program.account.yieldTokenPosition.fetch(address);
         return deserializeYtPosition(x);
     }
+    /** Batch fetch multiple YT positions in a single RPC call */
+    async fetchYtPositions(addresses) {
+        if (addresses.length === 0)
+            return [];
+        const results = await this.program.account.yieldTokenPosition.fetchMultiple(addresses);
+        return results.map((x) => (x ? deserializeYtPosition(x) : null));
+    }
     async fetchJitoRestakingSyMeta(address) {
         const x = await this.jitoRestakingSyProgram.account.syMeta.fetch(address);
         return (0, exponent_types_1.deserializeJitoRestakingSyMetaAccountRaw)(x);
@@ -216,8 +300,234 @@ class ExponentFetcher {
         const x = await this.genericStandardProgram.account.syMeta.fetch(address);
         return (0, exponent_types_1.deserializeGenericSyMetaAccountRaw)(x);
     }
+    async fetchAllMarketThree() {
+        //TODO Replace with the following code when all damaged markets are removed onchain
+        // const marketsProgramAccounts: ProgramAccount<MarketThreeRaw>[] =
+        //   await this.exponentClmmProgram.account.marketThree.all()
+        // return marketsProgramAccounts.map(({ account }) => deserializeMarketThree(account))
+        const MARKET_THREE_DISCRIMINATOR = Buffer.from([242, 240, 26, 15, 148, 186, 185, 205]);
+        const marketsProgramAccounts = await this.connection.getProgramAccounts(this.exponentClmmProgram.programId, {
+            filters: [
+                {
+                    memcmp: {
+                        offset: 0,
+                        bytes: bs58_1.default.encode(MARKET_THREE_DISCRIMINATOR),
+                    },
+                },
+            ],
+        });
+        return marketsProgramAccounts
+            .map(({ account, pubkey }) => {
+            try {
+                return this.exponentClmmProgram.coder.accounts.decode("marketThree", account.data);
+            }
+            catch (error) {
+                return null;
+            }
+        })
+            .filter((m) => !!m);
+    }
+    async fetchMarketThree(address) {
+        try {
+            const m = await this.exponentClmmProgram.account.marketThree.fetch(address);
+            return deserializeMarketThree(m);
+        }
+        catch (e) {
+            console.error(`Error fetching market ${address.toBase58()}`);
+            console.error(e);
+            throw e;
+        }
+    }
+    async fetchAllMarketThreeTicks() {
+        const TICKS_DISCRIMINATOR = Buffer.from([122, 104, 41, 141, 214, 36, 222, 37]);
+        const ticksAccounts = await this.connection.getProgramAccounts(this.exponentClmmProgram.programId, {
+            filters: [
+                {
+                    memcmp: {
+                        offset: 0,
+                        bytes: bs58_1.default.encode(TICKS_DISCRIMINATOR),
+                    },
+                },
+            ],
+        });
+        return ticksAccounts.map(({ account }) => deserializeMarketThreeTicks(account.data));
+    }
+    async fetchMarketThreeTicks(address) {
+        try {
+            const m = (await this.connection.getAccountInfo(address)).data;
+            return deserializeMarketThreeTicks(m);
+        }
+        catch (e) {
+            console.error(`Error fetching market ${address.toBase58()}`);
+            console.error(e);
+            throw e;
+        }
+    }
 }
 exports.ExponentFetcher = ExponentFetcher;
+function deserializeMarketThreeTicks(data) {
+    let offset = 8;
+    const MAX_TICK_NODES = 100;
+    const PERSONAL_TICK_YIELD_TRACKER_SIZE = 3;
+    const readPubkey = () => {
+        const pk = new anchor_1.web3.PublicKey(data.slice(offset, offset + 32));
+        offset += 32;
+        return pk;
+    };
+    const readNumber = () => {
+        // Number is 32 bytes (4 x u64)
+        const nums = [];
+        for (let i = 0; i < 4; i++) {
+            nums.push(new anchor_1.BN(data.slice(offset + i * 8, offset + (i + 1) * 8), undefined, "le"));
+        }
+        offset += 32;
+        return parseFloat(precise_number_1.PreciseNumber.fromRaw(nums).valueString);
+    };
+    // ─── Parse RedBlackTree slab ───────────────────────────────────────────────
+    // repr(C) gives: root: u32, pad to align NodeAllocator's u64, then the NodeAllocator header
+    const root = data.readUInt32LE(offset);
+    offset += 4;
+    const padTo8 = 12;
+    offset += padTo8;
+    // NodeAllocator<T=RBNode<u32,PriceNode>, N=MAX_PRICE_NODES, R=3>
+    // header: size:u64, bump_index:u32, free_list_head:u32
+    const tickTreeSize = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+    const ticksTreeBump = data.readUInt32LE(offset);
+    offset += 4;
+    const ticksTreeFreeIdx = data.readUInt32LE(offset);
+    offset += 4;
+    const ticks = [];
+    for (let i = 0; i < MAX_TICK_NODES; i++) {
+        const left = data.readUInt32LE(offset);
+        offset += 4;
+        const right = data.readUInt32LE(offset);
+        offset += 4;
+        const parent = data.readUInt32LE(offset);
+        offset += 4;
+        offset += 4; // skip color
+        const apyBasePoints = data.readUInt32LE(offset);
+        offset += 8;
+        const feeGrowthOutsidePt = readU128LE(data, offset);
+        offset += 16;
+        const feeGrowthOutsideSy = readU128LE(data, offset);
+        offset += 16;
+        const liquidityNet = data.readBigInt64LE(offset);
+        offset += 8;
+        const liquidityGross = data.readBigInt64LE(offset);
+        offset += 8;
+        const impliedRate = data.readDoubleLE(offset);
+        offset += 8;
+        const principalPt = data.readBigInt64LE(offset);
+        offset += 8;
+        const principalSy = data.readBigInt64LE(offset);
+        offset += 8;
+        const principalShareSupply = data.readBigInt64LE(offset);
+        offset += 8;
+        // Parse FarmYieldTrackers (3 trackers x 32 bytes each)
+        const farms = [];
+        for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
+            farms.push({ lastSeenIndex: readNumber() });
+        }
+        // Parse EmissionYieldTrackers (3 trackers x 64 bytes each)
+        const emissions = [];
+        for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
+            const lastSeenIndex = readNumber();
+            const lastPositionIndex = readNumber();
+            emissions.push({ lastSeenIndex, lastPositionIndex });
+        }
+        // Parse last_split_epoch (u64)
+        const lastSplitEpoch = data.readBigUInt64LE(offset);
+        offset += 8;
+        // Skip padding (u64)
+        offset += 8;
+        if (apyBasePoints === 0)
+            continue;
+        ticks.push({
+            apyBasePoints,
+            liquidityNet,
+            feeGrowthOutsidePt,
+            feeGrowthOutsideSy,
+            liquidityGross,
+            impliedRate,
+            principalPt,
+            principalSy,
+            principalShareSupply,
+            farms,
+            emissions,
+            lastSplitEpoch,
+        });
+        // console.log(ticks)
+    }
+    const market = readPubkey();
+    const feeGrowthIndexGlobalPt = readU128LE(data, offset);
+    offset += 16;
+    const feeGrowthIndexGlobalSy = readU128LE(data, offset);
+    offset += 16;
+    const currentPrefixSum = data.readBigUInt64LE(offset); // Active liquidity at current tick
+    offset += 8;
+    const currentSpotPrice = data.readDoubleLE(offset);
+    offset += 8;
+    const currentTick = data.readUint32LE(offset);
+    offset += 4;
+    offset += 12; // padding
+    return {
+        ticksTree: ticks,
+        market,
+        feeGrowthIndexGlobalPt,
+        feeGrowthIndexGlobalSy,
+        currentPrefixSum,
+        currentSpotPrice,
+        currentTick,
+    };
+}
+exports.deserializeMarketThreeTicks = deserializeMarketThreeTicks;
+function deserializeMarketThree(m) {
+    return {
+        addressLookupTable: m.addressLookupTable,
+        mintSy: m.mintSy,
+        mintPt: m.mintPt,
+        vault: m.vault,
+        tokenSyEscrow: m.tokenSyEscrow,
+        tokenPtEscrow: m.tokenPtEscrow,
+        tokenFeeTreasurySy: m.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: m.tokenFeeTreasuryPt,
+        selfAddress: m.selfAddress,
+        syProgram: m.syProgram,
+        statusFlags: m.statusFlags,
+        cpiSyAccounts: m.cpiSyAccounts,
+        isCurrentFlashSwap: m.isCurrentFlashSwap,
+        lpFarm: m.lpFarm,
+        mintYt: m.mintYt,
+        tokenYtEscrow: m.tokenYtEscrow,
+        emissions: {
+            trackers: m.emissions.trackers.map((t) => ({
+                tokenEscrow: t.tokenEscrow,
+                lpShareIndex: deserializeAnchorizedPNum(t.lpShareIndex),
+                lastSeenStaged: Number(t.lastSeenStaged),
+            })),
+        },
+        liquidityNetBalanceLimits: m.liquidityNetBalanceLimits,
+        admin: m.admin,
+        ticks: m.ticks,
+        configurationOptions: {
+            lnFeeRateRoot: m.configurationOptions.lnFeeRateRoot,
+            treasuryFeeBps: m.configurationOptions.treasuryFeeBps,
+            minLpTickAmount: BigInt(m.configurationOptions.minLpTickAmount.toString()),
+            epsilonClamp: m.configurationOptions.epsilonClamp,
+            maxLpSupply: BigInt(m.configurationOptions.maxLpSupply.toString()),
+            tickSpace: m.configurationOptions.tickSpace,
+        },
+        financials: {
+            expirationTs: BigInt(m.financials.expirationTs),
+            ptBalance: BigInt(m.financials.ptBalance.toString()),
+            syBalance: BigInt(m.financials.syBalance.toString()),
+            liquidityBalance: BigInt(m.financials.liquidityBalance.toString()),
+        },
+        cpiCoreAccounts: m.cpiCoreAccounts,
+        exponentCoreProgram: m.exponentCoreProgram,
+    };
+}
 function deserializeMarketTwo(m) {
     return {
         ptBalance: BigInt(m.financials.ptBalance.toString()),
@@ -255,6 +565,33 @@ function deserializeMarketTwo(m) {
         seedId: m.seedId,
     };
 }
+function deserializeLpPositionCLMM(x) {
+    return {
+        owner: x.owner,
+        market: x.market,
+        feeInsideLastPt: BigInt(x.feeInsideLastPt.toString()),
+        feeInsideLastSy: BigInt(x.feeInsideLastSy.toString()),
+        lpBalance: BigInt(x.lpBalance.toString()),
+        tokensOwedSy: BigInt(x.tokensOwedSy.toString()),
+        tokensOwedPt: BigInt(x.tokensOwedPt.toString()),
+        lowerTickIdx: x.lowerTickIdx,
+        upperTickIdx: x.upperTickIdx,
+        farms: x.farms.trackers.map((t) => ({
+            staged: BigInt(t.staged.toString()),
+            lastSeenIndex: parseFloat(precise_number_1.PreciseNumber.fromRaw(t.lastSeenIndex[0]).valueString),
+        })),
+        shareTrackers: x.shareTrackers.trackers.map((tracker) => ({
+            tickIdx: tracker.tickIdx,
+            rightTickIdx: tracker.rightTickIdx,
+            splitEpoch: BigInt(tracker.splitEpoch.toString()),
+            lpShare: BigInt(tracker.lpShare.toString()),
+            emissions: tracker.emissions.trackers.map((e) => ({
+                staged: BigInt(e.staged.toString()),
+                lastSeenIndex: parseFloat(precise_number_1.PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
+            })),
+        })),
+    };
+}
 function deserializeVault(x) {
     return {
         syProgram: x.syProgram,
@@ -285,6 +622,227 @@ function deserializeVault(x) {
         maxPySupply: BigInt(x.maxPySupply.toString()),
     };
 }
+function deserializeOrderbook(data) {
+    let offset = 0;
+    // 1) Skip Anchor discriminator
+    offset += anchor_1.DISCRIMINATOR_SIZE;
+    const readPubkey = () => {
+        const pk = new anchor_1.web3.PublicKey(data.slice(offset, offset + 32));
+        offset += 32;
+        return pk;
+    };
+    // ConfigurationOptions struct
+    const thresholdAmount = data.readBigUInt64LE(offset);
+    offset += 8;
+    const lnMakerFeeRate = data.readDoubleLE(offset);
+    offset += 8;
+    const lnTakerFeeRate = data.readDoubleLE(offset);
+    offset += 8;
+    const priceDecimals = data.readUint8(offset);
+    offset += 1;
+    // Skip ConfigurationOptions padding: _placeholder_one[15] + _placeholder_two[32] + _placeholder_three[32] + _placeholder_four[32] = 111 bytes
+    offset += 111;
+    // Pubkeys
+    const vault = readPubkey();
+    const yieldPosition = readPubkey();
+    const addressLookupTable = readPubkey();
+    const exponentCoreProgram = readPubkey();
+    const syProgram = readPubkey();
+    const tokenEscrowSy = readPubkey();
+    const tokenEscrowYt = readPubkey();
+    const tokenEscrowPt = readPubkey();
+    const cpiAccountOrderbook = readPubkey();
+    const admin = readPubkey();
+    // Skip last_sy_exchange_rate (Number type = 32 bytes)
+    offset += 32;
+    // OrderbookFinancials struct
+    // Skip last_seen_sy_index (Number type = 32 bytes)
+    offset += 32;
+    const ytBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const syBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const ptBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const ytFeeBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const syFeeBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const ptFeeBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const stagedSyBalance = data.readBigUInt64LE(offset);
+    offset += 8;
+    const expirationTs = data.readUInt32LE(offset);
+    offset += 4;
+    // Skip financials _padding: [u8; 4]
+    offset += 4;
+    const configurationOptions = {
+        priceDecimals,
+        thresholdAmount,
+        lnMakerFeeRate,
+        lnTakerFeeRate,
+    };
+    const financials = {
+        expirationTs,
+        syBalance: syBalance,
+        ytBalance: ytBalance,
+        ptBalance: ptBalance,
+        ytFeeBalance,
+        syFeeBalance,
+        ptFeeBalance,
+        stagedSy: stagedSyBalance,
+    };
+    // console.log("financials", financials)
+    // ─── Parse RedBlackTree slab ───────────────────────────────────────────────
+    // repr(C) gives: root: u32, pad to align NodeAllocator’s u64, then the NodeAllocator header
+    const root = data.readUInt32LE(offset);
+    offset += 4;
+    const padTo8 = 8;
+    offset += padTo8;
+    // NodeAllocator<T=RBNode<u32,PriceNode>, N=MAX_PRICE_NODES, R=3>
+    // header: size:u64, bump_index:u32, free_list_head:u32
+    const priceTreeSize = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+    const _priceTreeBump = data.readUInt32LE(offset);
+    offset += 4;
+    const _priceTreeFreeIdx = data.readUInt32LE(offset);
+    offset += 4;
+    // each RBNode entry = registers[3] + key:u32 + first_offer:u32
+    const prices = [];
+    for (let i = 0; i < exponent_types_2.MAX_PRICE_NODES; i++) {
+        const left = data.readUInt32LE(offset);
+        offset += 4;
+        const right = data.readUInt32LE(offset);
+        offset += 4;
+        const parent = data.readUInt32LE(offset);
+        offset += 4;
+        offset += 4; // skip color
+        const key = data.readUInt32LE(offset);
+        offset += 4;
+        const firstOfferSellYt = data.readUInt32LE(offset);
+        offset += 4;
+        const firstOfferBuyYt = data.readUInt32LE(offset);
+        offset += 4;
+        const lastOfferSellYt = data.readUInt32LE(offset);
+        offset += 4;
+        const lastOfferBuyYt = data.readUInt32LE(offset);
+        offset += 4;
+        if (key === 0)
+            continue;
+        prices.push({ key, firstOfferSellYt, firstOfferBuyYt, lastOfferSellYt, lastOfferBuyYt, parent, left, right });
+    }
+    // ─── Parse Offers slab ────────────────────────────────────────────────────
+    // NodeAllocator<Offer, MAX_OFFERS, 4>
+    // header: size:u64, bump_index:u32, free_list_head:u32
+    const offersSize = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+    const _offersBump = data.readUInt32LE(offset);
+    offset += 4;
+    const _offersFreeIdx = data.readUInt32LE(offset);
+    offset += 4;
+    const offers = [];
+    for (let i = 0; i < exponent_types_2.MAX_OFFERS; i++) {
+        const register = data.readUInt32LE(offset);
+        offset += 4;
+        const nextOfferPointer = data.readUInt32LE(offset);
+        offset += 4;
+        const userVaultPointer = data.readUInt32LE(offset);
+        offset += 4;
+        const pricePointer = data.readUInt32LE(offset);
+        offset += 4;
+        const amount = data.readBigUInt64LE(offset);
+        offset += 8;
+        const expiryAt = data.readUInt32LE(offset);
+        offset += 4;
+        const createdAt = data.readUInt32LE(offset);
+        offset += 4;
+        const virtualOffer = data.readUInt8(offset) !== 0;
+        offset += 1;
+        const orderTypeFlag = data.readUInt8(offset);
+        offset += 1;
+        const fillOrKill = data.readUInt8(offset) !== 0;
+        offset += 1;
+        offset += 5; // reserved padding
+        if (userVaultPointer === 0)
+            continue;
+        offers.push({
+            nextOfferPointer,
+            amount,
+            userVaultPointer,
+            expiryAt,
+            createdAt,
+            virtualOffer,
+            orderTypeFlag,
+            fillOrKill,
+            pricePointer,
+        });
+    }
+    // ─── Parse UserEscrow slab ────────────────────────────────────────────────
+    // NodeAllocator<UserEscrow, MAX_USER_ESCROWS, 2>
+    // header: size:u64, bump_index:u32, free_list_head:u32
+    const escSize = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+    const _escBump = data.readUInt32LE(offset);
+    offset += 4;
+    const _escFreeIdx = data.readUInt32LE(offset);
+    offset += 4;
+    // each Node = [ no registers ] + UserEscrow.value
+    const userEscrows = [];
+    for (let i = 0; i < exponent_types_2.MAX_USER_ESCROWS; i++) {
+        const register = data.readUInt32LE(offset);
+        offset += 4;
+        const register2 = data.readUInt32LE(offset);
+        offset += 4;
+        const user = new anchor_1.web3.PublicKey(data.slice(offset, offset + 32));
+        offset += 32;
+        /*const yieldIndex = data.readBigUInt64LE(offset).toString();*/ offset += 32;
+        const ptAmount = data.readBigUInt64LE(offset);
+        offset += 8;
+        const syAmount = data.readBigUInt64LE(offset);
+        offset += 8;
+        const ytAmount = data.readBigUInt64LE(offset);
+        offset += 8;
+        const stakedYtAmount = data.readBigInt64LE(offset);
+        offset += 8;
+        const staged = data.readBigInt64LE(offset);
+        offset += 8;
+        offset += 8; // reserved
+        if (user.toBase58() == "11111111111111111111111111111111")
+            continue;
+        userEscrows.push({ user, yieldIndex: 0, ptAmount, syAmount, ytAmount, stakedYtAmount, staged });
+    }
+    // ─── Finally, seed_id + signer_bump + reserved ─────────────────────────────
+    // seed_id: [u8; 4]
+    const seedId = [
+        data.readUInt8(offset),
+        data.readUInt8(offset + 1),
+        data.readUInt8(offset + 2),
+        data.readUInt8(offset + 3),
+    ];
+    offset += 4;
+    // signer_bump: [u8; 1]
+    const signerBump = data.readUInt8(offset);
+    offset += 1;
+    // _reserved: [u8; 3] - skip
+    offset += 3;
+    return {
+        vault,
+        yieldPosition,
+        addressLookupTable,
+        exponentCoreProgram,
+        syProgram,
+        admin,
+        tokenEscrowSy,
+        tokenEscrowYt,
+        tokenEscrowPt,
+        cpiAccountOrderbook,
+        financials,
+        prices,
+        configurationOptions,
+        offers,
+        userEscrows,
+    };
+}
 function deserializeMarginfiSyMeta(x) {
     return {
         ...x,
@@ -320,6 +878,7 @@ function deserializeLpPosition(x) {
         })),
     };
 }
+exports.deserializeLpPosition = deserializeLpPosition;
 function deserializeYtPosition(x) {
     return {
         owner: x.owner,
@@ -329,6 +888,7 @@ function deserializeYtPosition(x) {
         emissions: x.emissions.map(deserializeYieldTokenTracker),
     };
 }
+exports.deserializeYtPosition = deserializeYtPosition;
 function deserializeYieldTokenTracker(x) {
     return {
         staged: BigInt(x.staged.toString()),
@@ -340,10 +900,13 @@ async function fetchKaminoReserve(address, connection) {
     if (!reserve) {
         throw new Error("Reserve not found");
     }
+    const rawScopePriceFeed = reserve.config.tokenInfo.scopeConfiguration.priceFeed;
+    const scopePriceFeed = rawScopePriceFeed.equals(anchor_1.web3.PublicKey.default) ? undefined : rawScopePriceFeed;
     return {
         lendingMarket: reserve.lendingMarket,
         baseMint: reserve.liquidity.mintPubkey,
         assetShareValue: reserve.getCollateralExchangeRate(),
+        scopePriceFeed,
     };
 }
 exports.fetchKaminoReserve = fetchKaminoReserve;
@@ -406,24 +969,7 @@ function deserializeAnchorizedPNum(x) {
 /** Fetch the exchange rate of a JitoRestaking vault's VRT to JitoSOL */
 async function fetchJitoVaultData({ connection, vaultAddress, }) {
     const vaultAccountInfo = await connection.getAccountInfo(vaultAddress);
-    const d = vaultAccountInfo.data;
-    // the vault has an 8 byte discriminator at the beginning
-    const discriminatorOffset = 8;
-    const vrtMintOffset = 32 + discriminatorOffset;
-    const vrtSupplyOffset = 96 + discriminatorOffset;
-    const jitoVaultTotalDepositsOffset = 104 + discriminatorOffset;
-    const mintBase = new anchor_1.web3.PublicKey(d.slice(vrtMintOffset, vrtMintOffset + 32));
-    // For Borsh, numbers are serialized in little-endian format
-    const jitoVaultTotalSharesBuffer = d.slice(vrtSupplyOffset, vrtSupplyOffset + 8);
-    const jitoVaultTotalShares = new anchor_1.BN(jitoVaultTotalSharesBuffer, "le");
-    const jitoVaultTotalDepositsBuffer = d.slice(jitoVaultTotalDepositsOffset, jitoVaultTotalDepositsOffset + 8);
-    const jitoVaultTotalDeposits = new anchor_1.BN(jitoVaultTotalDepositsBuffer, "le");
-    const jitoVaultTotalSharesD = new decimal_js_1.default(jitoVaultTotalShares.toString());
-    const jitoVaultTotalDepositsD = new decimal_js_1.default(jitoVaultTotalDeposits.toString());
-    const exchangeRate = jitoVaultTotalDepositsD.isZero()
-        ? "1.0"
-        : jitoVaultTotalDepositsD.div(jitoVaultTotalSharesD).toString();
-    return { exchangeRate: parseFloat(exchangeRate), mintBase };
+    return (0, jito_1.decodeJitoVaultData)(vaultAccountInfo.data);
 }
 async function fetchJitoSolToSolExchangeRate({ connection, interfaceType, accounts, }) {
     if (interfaceType.splStakePool) {
@@ -438,16 +984,13 @@ async function fetchSplStakePoolIndex({ connection, stakePool, }) {
 }
 exports.fetchSplStakePoolIndex = fetchSplStakePoolIndex;
 async function fetchPerenaStablePoolData({ connection, perenaStablePool, }) {
-    const [lpMint, _] = anchor_1.web3.PublicKey.findProgramAddressSync([perenaStablePool.toBuffer(), Buffer.from("liquidity")], new anchor_1.web3.PublicKey("NUMERUNsFCP3kuNmWZuXtm1AaQCPj9uw6Guv2Ekoi5P"));
+    const lpMint = (0, perena_1.getPerenaLpMint)(perenaStablePool);
     const [accountInfo, lpMintInfo] = await connection.getMultipleAccountsInfo([perenaStablePool, lpMint]);
-    const lpMintDeserialized = spl_token_2.MintLayout.decode(lpMintInfo.data);
-    const d = accountInfo.data;
-    const discriminatorOffset = 8;
-    const invTOffset = discriminatorOffset + 32 + 32 + 32 + 32; // 4 Pubkeys before invT
-    const invTBuffer = d.slice(invTOffset, invTOffset + 8);
-    const invT = Buffer.from(invTBuffer).readBigUInt64LE(0);
-    const exchangeRate = new decimal_js_1.default(invT.toString()).div(new decimal_js_1.default(lpMintDeserialized.supply.toString())).toString();
-    return { lpSupply: lpMintDeserialized.supply, invT, exchangeRate, lpMint };
+    const { lpSupply, invT, exchangeRate } = (0, perena_1.getPerenaStablePoolData)({
+        perenaStablePoolData: accountInfo.data,
+        lpMintData: lpMintInfo.data,
+    });
+    return { lpSupply, invT, exchangeRate, lpMint };
 }
 exports.fetchPerenaStablePoolData = fetchPerenaStablePoolData;
 /**
@@ -477,40 +1020,14 @@ exports.fetchJitoRestaking = fetchJitoRestaking;
  * and tracks last_* values to compute the next index increment similar to the program.
  */
 async function fetchJupiterPerpsIndex({ connection, pool, lastFeeUsdResetUnixTimestamp, lastRealizedFeeUsd, lastAumUsd, currentIndex, lastRealizedFeeUsdUpdateUnixTimestamp, }) {
-    // Decode pool account using helper that leverages Anchor 0.29.0
     const accountInfo = await connection.getAccountInfo(pool);
-    const account = (0, jupiter_perps_idl_1.decodePoolAccount)(accountInfo?.data);
-    const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
-    let newFeesBn;
-    if (lastRealizedFeeUsdUpdateUnixTimestamp === 0) {
-        newFeesBn = new anchor_1.BN(account.poolApr.realizedFeeUsd.toString());
-    }
-    else if (Number(account.poolApr.lastUpdated) > lastFeeUsdResetUnixTimestamp) {
-        const timeBetweenResets = Number(account.poolApr.lastUpdated) - lastFeeUsdResetUnixTimestamp;
-        const feeAprBps = new anchor_1.BN(account.poolApr.feeAprBps);
-        const estTotalFees = lastAumUsd.gt(new anchor_1.BN(0)) && timeBetweenResets > 0
-            ? feeAprBps.mul(lastAumUsd).mul(new anchor_1.BN(timeBetweenResets)).div(new anchor_1.BN(SECONDS_PER_YEAR)).div(new anchor_1.BN(10_000))
-            : new anchor_1.BN(0);
-        const missingFees = estTotalFees.sub(lastRealizedFeeUsd);
-        const feesSinceReset = new anchor_1.BN(account.poolApr.realizedFeeUsd.toString());
-        newFeesBn = missingFees.add(feesSinceReset);
-    }
-    else {
-        newFeesBn = new anchor_1.BN(account.poolApr.realizedFeeUsd.toString()).sub(lastRealizedFeeUsd);
-    }
-    const aumUsd = new anchor_1.BN(account.aumUsd.toString());
-    const indexIncrease = new decimal_js_1.default(newFeesBn.toString()).div(new decimal_js_1.default(aumUsd.toString())).toNumber();
-    const currentIndexNum = parseFloat(precise_number_1.PreciseNumber.fromRaw(currentIndex[0]).valueString);
-    const nextIndex = currentIndexNum + indexIncrease;
-    return {
-        index: nextIndex,
-        newState: {
-            lastAumUsd: aumUsd,
-            lastRealizedFeeUsd: new anchor_1.BN(account.poolApr.realizedFeeUsd.toString()),
-            lastFeeUsdResetUnixTimestamp: Number(account.poolApr.lastUpdated),
-            lastRealizedFeeUsdUpdateUnixTimestamp: Math.floor(Date.now() / 1000),
-        },
-    };
+    return (0, jupiter_1.calculateJupiterPerpsIndex)({ pool: accountInfo.data }, {
+        lastFeeUsdResetUnixTimestamp,
+        lastRealizedFeeUsd,
+        lastAumUsd,
+        currentIndex,
+        lastRealizedFeeUsdUpdateUnixTimestamp,
+    });
 }
 exports.fetchJupiterPerpsIndex = fetchJupiterPerpsIndex;
 async function fetchPyth(connection) {
@@ -543,28 +1060,27 @@ async function fetchGenericSyMetaIndex({ connection, genericSyMeta, }) {
 }
 exports.fetchGenericSyMetaIndex = fetchGenericSyMetaIndex;
 async function fetchFragmetricIndex({ connection, fragmetricFund, }) {
-    const account = await connection.getAccountInfo(fragmetricFund);
-    const coder = new anchor_2.BorshCoder(fragmetric_idl_1.IDL);
-    const data = coder.accounts.decode("FundAccount", account.data);
-    const index = Number(data.one_receipt_token_as_sol) / Number(10 ** data.receipt_token_decimals);
-    const receiptTokenMint = new anchor_1.web3.PublicKey(data.receipt_token_mint);
-    const wrappedTokenMint = new anchor_1.web3.PublicKey(data.wrapped_token.mint);
+    const fragmetricFundRaw = await connection.getAccountInfo(fragmetricFund);
+    const { index, receiptTokenMint, wrappedTokenMint } = (0, fragmetric_1.calculateFragmetricIndex)({
+        fragmetricFund: fragmetricFundRaw.data,
+    });
     return { index, receiptTokenMint, wrappedTokenMint };
 }
 exports.fetchFragmetricIndex = fetchFragmetricIndex;
 async function fetchJupiterLendIndex({ connection, jupiterLendAccount, }) {
     const account = await connection.getAccountInfo(jupiterLendAccount);
-    const coder = new anchor_2.BorshCoder(jupiter_lend_idl_1.IDL);
-    const data = coder.accounts.decode("Lending", account.data);
-    const index = Number(data.token_exchange_price) / Number(10 ** 12);
-    const tokenReservesLiquidity = data.token_reserves_liquidity;
-    const lendingSupplyPosition = data.supply_position_on_liquidity;
-    const rewardsRateModel = data.rewards_rate_model;
     const rateModel = jupiterLendAccount.equals(new anchor_1.web3.PublicKey("BeAqbxfrcXmzEYT2Ra62oW2MqkuFDHaCtps47Mzg6Zj3"))
         ? new anchor_1.web3.PublicKey("Acvyi9HBGmqh3Exe1N4PjBVyY8fokq2AdC6fSLqV6KSo")
         : new anchor_1.web3.PublicKey("6iHHKAK9Mqjn57CVmWe4szAPyTH8s8pniXSj6vWaKW5r");
-    console.log("token reserves liquidity in fetch jupiter lend index", tokenReservesLiquidity.toBase58());
-    return { index, baseTokenMint: data.mint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel, rateModel };
+    const { index, baseTokenMint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel } = (0, jupiter_1.calculateJupiterLendIndex)({ jupiterLend: account.data });
+    return {
+        rateModel,
+        index,
+        baseTokenMint,
+        tokenReservesLiquidity,
+        lendingSupplyPosition,
+        rewardsRateModel,
+    };
 }
 exports.fetchJupiterLendIndex = fetchJupiterLendIndex;
 async function fetchKaminoVaultIndex({ connection, kaminoVaultAccount, }) {
@@ -593,24 +1109,18 @@ async function fetchKaminoVaultIndex({ connection, kaminoVaultAccount, }) {
 exports.fetchKaminoVaultIndex = fetchKaminoVaultIndex;
 async function fetchFragmetricSupportedTokenIndex({ connection, fragmetricFund, index, }) {
     const account = await connection.getAccountInfo(fragmetricFund);
-    const coder = new anchor_2.BorshCoder(fragmetric_idl_1.IDL);
-    const data = coder.accounts.decode("FundAccount", account.data);
-    const syIndex = Number(10 ** data.supported_tokens[index].decimals) /
-        Number(data.supported_tokens[index].one_token_as_receipt_token);
-    const receiptTokenMint = new anchor_1.web3.PublicKey(data.receipt_token_mint);
-    const wrappedTokenMint = new anchor_1.web3.PublicKey(data.wrapped_token.mint);
-    return { index: syIndex, receiptTokenMint, wrappedTokenMint };
+    return (0, fragmetric_1.calculateFragmetricSupportedTokenIndex)({ fragmetricFund: account.data }, index);
 }
 exports.fetchFragmetricSupportedTokenIndex = fetchFragmetricSupportedTokenIndex;
 async function fetchMeteoraIndex({ connection, accounts, onChainTime, }) {
     try {
         const VIRTUAL_PRICE_PRECISION = new anchor_1.BN(100_000_000);
-        const pool = await (0, meteora_idl_1.decodePoolAccount)(connection, accounts.pool);
+        const pool = await (0, meteora_idl_1.fetchPoolAccount)(connection, accounts.pool);
         const poolMint = await (0, spl_token_1.getMint)(connection, pool.lpMint);
         const poolLpSupply = new anchor_1.BN(poolMint.supply.toString());
         const poolLpDecimals = Number(poolMint.decimals.toString());
-        const vaultA = await (0, meteora_idl_1.decodeVaultAccount)(connection, accounts.vaultA);
-        const vaultB = await (0, meteora_idl_1.decodeVaultAccount)(connection, accounts.vaultB);
+        const vaultA = await (0, meteora_idl_1.fetchVaultAccount)(connection, accounts.vaultA);
+        const vaultB = await (0, meteora_idl_1.fetchVaultAccount)(connection, accounts.vaultB);
         const vaultLpMintA = await (0, spl_token_1.getMint)(connection, vaultA.lpMint);
         const vaultLpMintB = await (0, spl_token_1.getMint)(connection, vaultB.lpMint);
         const vaultALpSupply = vaultLpMintA.supply;
@@ -640,7 +1150,6 @@ async function fetchMeteoraIndex({ connection, accounts, onChainTime, }) {
 exports.fetchMeteoraIndex = fetchMeteoraIndex;
 async function fetchAdrenaIndex({ connection, accounts, previousTotalFees, currentIndex, }) {
     try {
-        const zero = new anchor_1.BN(0);
         // Fetch all account data in a single RPC call
         const accountInfos = await connection.getMultipleAccountsInfo([
             accounts.pool,
@@ -652,19 +1161,13 @@ async function fetchAdrenaIndex({ connection, accounts, previousTotalFees, curre
         if (!accountInfos[0] || !accountInfos[1] || !accountInfos[2] || !accountInfos[3] || !accountInfos[4]) {
             throw new Error("One or more Adrena accounts not found");
         }
-        // Decode accounts using adrena-idl package functions
-        const { poolAccount, custodyAccounts } = (0, adrena_idl_1.decodePoolAndCustodyAccounts)(accountInfos);
-        // @ts-ignore
-        const currentTotalFees = (0, adrena_idl_1.calculateTotalFeesFromCustodies)(custodyAccounts);
-        let yieldIncrement;
-        let aumValue = poolAccount.aumUsd.low;
-        if (aumValue.eq(zero)) {
-            yieldIncrement = 0;
-        }
-        let feeDifference = currentTotalFees.gte(previousTotalFees) ? currentTotalFees.sub(previousTotalFees) : zero;
-        yieldIncrement = feeDifference.toNumber() / aumValue.toNumber();
-        let currentIndexNumber = parseFloat(precise_number_1.PreciseNumber.fromRaw(currentIndex[0]).valueString);
-        return { index: currentIndexNumber + yieldIncrement };
+        return (0, adrena_1.calculateAdrenaIndex)({
+            pool: accountInfos[0].data,
+            custody1: accountInfos[1].data,
+            custody2: accountInfos[2].data,
+            custody3: accountInfos[3].data,
+            custody4: accountInfos[4].data,
+        }, previousTotalFees, currentIndex);
     }
     catch (error) {
         throw error;
@@ -672,70 +1175,65 @@ async function fetchAdrenaIndex({ connection, accounts, previousTotalFees, curre
 }
 exports.fetchAdrenaIndex = fetchAdrenaIndex;
 async function fetchSanctumIndex({ connection, accounts, }) {
-    try {
-        const poolState = await (0, sanctum_idl_1.decodePoolStateAccount)(connection, accounts.poolState);
-        const lpMint = await (0, spl_token_1.getMint)(connection, accounts.lpMint);
-        const zeroBn = new anchor_1.BN(0);
-        const precision = new anchor_1.BN(10 ** lpMint.decimals);
-        const lpTokenSupplyBn = new anchor_1.BN(lpMint.supply.toString());
-        const poolTotalSolValueBn = new anchor_1.BN(poolState.totalSolValue.toString());
-        if (lpTokenSupplyBn.eq(zeroBn) || poolTotalSolValueBn.eq(zeroBn)) {
-            return 1;
-        }
-        const exchangeRateBn = lpTokenSupplyBn.mul(precision).div(poolTotalSolValueBn);
-        const exchangeRate = new decimal_js_1.default(exchangeRateBn.toString()).div(precision.toString()).toNumber();
-        return 1 / exchangeRate; // We return inverse exchange rate
-    }
-    catch (error) {
-        throw error;
-    }
+    const [poolStateAccountRaw, lpMintAccountRaw] = await Promise.all([accounts.poolState, accounts.lpMint].map((pk) => connection.getAccountInfo(pk)));
+    return (0, sanctum_1.calculateSanctumIndex)({
+        poolStateAccountData: poolStateAccountRaw.data,
+        lpMintAccountData: lpMintAccountRaw.data,
+    });
 }
 exports.fetchSanctumIndex = fetchSanctumIndex;
 async function fetchSolsticeRedemptionRate({ connection, yieldPool, vestingSchedule, }) {
-    try {
-        // Fetch both accounts in a single RPC call for efficiency
-        const accountInfos = await connection.getMultipleAccountsInfo([yieldPool, vestingSchedule]);
-        if (!accountInfos[0] || !accountInfos[1]) {
-            throw new Error("One or more Solstice accounts not found");
-        }
-        // Decode accounts using solstice-idl package function
-        const { yieldPoolAccount, vestingScheduleAccount } = (0, solstice_idl_1.decodeYieldPoolAndVestingScheduleAccounts)(accountInfos);
-        // Extract fields for calculation (convert BN to bigint)
-        const poolTotalAssets = BigInt(yieldPoolAccount.total_assets.toString());
-        const poolSharesSupply = BigInt(yieldPoolAccount.shares_supply.toString());
-        const vestingAmount = BigInt(vestingScheduleAccount.vesting_amount.toString());
-        // Calculate total vested assets (mimicking the Rust logic)
-        let totalVestedAssets;
-        if (vestingAmount === 0n) {
-            totalVestedAssets = poolTotalAssets; // If no vesting amount, all assets are considered vested
-        }
-        else {
-            const vestingStart = BigInt(vestingScheduleAccount.start_time.toString());
-            const vestingEnd = BigInt(vestingScheduleAccount.end_time.toString());
-            const currentTime = BigInt(Math.floor(Date.now() / 1000)); // Current Unix timestamp
-            // Calculate unvested amount
-            let unvestedAmount;
-            if (currentTime > vestingEnd) {
-                unvestedAmount = 0n; // If current time passed the vesting end, no unvested amount
-            }
-            else {
-                unvestedAmount = (vestingAmount * (vestingEnd - currentTime)) / (vestingEnd - vestingStart);
-            }
-            totalVestedAssets = poolTotalAssets - unvestedAmount;
-        }
-        // Calculate redemption rate: (total_vested_assets + 1) / (pool_shares_supply + 1)
-        const redemptionRate = Number(totalVestedAssets + 1n) / Number(poolSharesSupply + 1n);
-        return {
-            redemptionRate,
-            totalAssets: poolTotalAssets.toString(),
-            sharesSupply: poolSharesSupply.toString(),
-            vestingAmount: vestingAmount.toString(),
-            totalVestedAssets: totalVestedAssets.toString(),
-        };
-    }
-    catch (error) {
-        throw error;
+    // Fetch both accounts in a single RPC call for efficiency
+    const accountInfos = await connection.getMultipleAccountsInfo([yieldPool, vestingSchedule]);
+    if (!accountInfos[0] || !accountInfos[1]) {
+        throw new Error("One or more Solstice accounts not found");
     }
+    return (0, solstice_1.calculateSolsticeRedemptionRate)({ yieldPool: accountInfos[0].data, vestingSchedule: accountInfos[1].data });
 }
 exports.fetchSolsticeRedemptionRate = fetchSolsticeRedemptionRate;
+const REFLECT_ORACLE_LEN = 17;
+const REFLECT_MAX_STALENESS_SLOTS = 150;
+async function fetchReflectRedemptionRate({ connection, oracle, }) {
+    const accountInfo = await connection.getAccountInfo(oracle);
+    if (!accountInfo) {
+        throw new Error("Reflect oracle account not found");
+    }
+    if (accountInfo.data.length !== REFLECT_ORACLE_LEN) {
+        throw new Error(`Reflect oracle account has invalid length: ${accountInfo.data.length}`);
+    }
+    const slot = Number(accountInfo.data.readBigUInt64LE(0));
+    const price = Number(accountInfo.data.readBigUInt64LE(8));
+    const precision = accountInfo.data.readUInt8(16);
+    const currentSlot = await connection.getSlot();
+    if (slot > currentSlot) {
+        throw new Error("Reflect oracle slot is ahead of the current slot");
+    }
+    const slotDelta = currentSlot - slot;
+    if (slotDelta > REFLECT_MAX_STALENESS_SLOTS) {
+        throw new Error("Reflect oracle data is stale");
+    }
+    const scale = Math.pow(10, precision);
+    if (scale === 0) {
+        throw new Error("Invalid oracle precision");
+    }
+    return price / scale;
+}
+exports.fetchReflectRedemptionRate = fetchReflectRedemptionRate;
+async function fetchOreExchangeRate({ connection, storeMint, stakeAccount, treasury, }) {
+    // Fetch all accounts in parallel for efficiency
+    const [storeMintInfo, stakeAccountInfo, treasuryAccountInfo] = await Promise.all([
+        connection.getAccountInfo(storeMint),
+        connection.getAccountInfo(stakeAccount),
+        connection.getAccountInfo(treasury),
+    ]);
+    if (!storeMintInfo || !stakeAccountInfo || !treasuryAccountInfo) {
+        throw new Error("One or more ORE accounts not found");
+    }
+    return (0, ore_1.calculateOreExchangeRate)({
+        stakeAccount: stakeAccountInfo.data,
+        treasuryAccount: treasuryAccountInfo.data,
+        storeMint: storeMintInfo.data,
+    });
+}
+exports.fetchOreExchangeRate = fetchOreExchangeRate;
 //# sourceMappingURL=exponentFetcher.js.map