@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/build/exponentVaults/vault.d.ts

@@ -1,9 +1,10 @@
 import { AccountMeta, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { ExponentPrices, ExponentVault as ExponentVaultAccountType, ExponentVaultsFetcher, PriceId } from "@exponent-labs/exponent-vaults-fetcher";
+import { ExponentPrices, ExponentVault as ExponentVaultAccountType, PriceId } from "@exponent-labs/exponent-vaults-fetcher";
 import { ExponentVaultsPDA, SeedId } from "@exponent-labs/exponent-vaults-pda";
 import * as exponentVaults from "../client/vaults";
 import { Environment } from "../environment";
 import { AumCalculator } from "./aumCalculator";
+import { ExponentVaultsFetcher } from "./fetcher";
 import { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver";
 type Numeric = bigint | number;
 export declare const SYNTHETIC_USD_MINT: PublicKey;
@@ -11,6 +12,12 @@ export declare const SYNTHETIC_USD_DECIMALS = 6;
 export declare const SYNTHETIC_USD9_MINT: PublicKey;
 export declare const SYNTHETIC_USD9_DECIMALS = 9;
 export declare const getSyntheticMintDecimals: (mint: PublicKey) => number | null;
+export declare function collectTrackedStrategyVaultPriceIds(state: {
+    tokenEntries: Array<{
+        priceId: unknown;
+    }>;
+    strategyPositions: Array<Record<string, unknown>>;
+}): Set<number>;
 export type DataOperator = "Equals" | "NotEquals" | "GreaterThan" | "GreaterThanOrEqualTo" | "LessThan" | "LessThanOrEqualTo";
 export type DataValue = {
     u8: number;
@@ -149,6 +156,10 @@ export interface UpdatePriceParams {
     remainingAccounts?: PublicKey[];
     priceId: number;
 }
+export interface UpdateStrategyVaultPricesOptions {
+    manager?: PublicKey;
+    priceIds?: Iterable<number>;
+}
 export interface QueueWithdrawalParams {
     depositor: PublicKey;
     lpAmount: Numeric;
@@ -441,6 +452,27 @@ export interface WrapperManagerUpdatePositionParams {
     exponentPrices?: PublicKey;
     systemProgram?: PublicKey;
 }
+export interface WrapperAddKaminoObligationPositionParams {
+    manager: PublicKey;
+    obligation: PublicKey;
+    lendingProgramId: PublicKey;
+    quotePriceId: exponentVaults.PriceId;
+    reservePriceMappings: exponentVaults.ReservePriceMapping[];
+    reserveFarmMappings?: exponentVaults.ReserveFarmMapping[];
+    minPriceStatusFlags: number;
+    remainingAccounts?: AccountMeta[];
+    exponentPrices?: PublicKey;
+    systemProgram?: PublicKey;
+}
+export interface WrapperUpsertKaminoObligationReservePriceMappingsParams {
+    manager: PublicKey;
+    obligation: PublicKey;
+    reservePriceMappings: exponentVaults.ReservePriceMapping[];
+    reserveFarmMappings?: exponentVaults.ReserveFarmMapping[];
+    remainingAccounts?: AccountMeta[];
+    exponentPrices?: PublicKey;
+    systemProgram?: PublicKey;
+}
 export type WrapperAddPolicyParams = AddPolicyParams;
 export type WrapperRemovePolicyParams = RemovePolicyParams;
 export type WrapperUpdatePolicyParams = UpdatePolicyParams;
@@ -467,6 +499,8 @@ export declare class ExponentVault {
     pda: ExponentVaultsPDA;
     aumCalculator: AumCalculator;
     private clmmTicksMap;
+    private kaminoFarmAuxAccountsMap;
+    private kaminoObligationFarmUserStates;
     static squadsVaultTxnResolver: SquadsVaultTxnResolver;
     constructor(params: {
         state: ExponentVaultAccountType;
@@ -486,6 +520,7 @@ export declare class ExponentVault {
     }): Promise<ExponentVault[]>;
     reload(connection?: Connection): Promise<ExponentVault>;
     private populateClmmTicksCache;
+    private populateKaminoFarmAuxAccountsCache;
     /**
      * Derive the PDA for a vault using its 8-byte seed identifier.
      */
@@ -518,6 +553,12 @@ export declare class ExponentVault {
     private strategyPositionAccountMetas;
     private tokenEntryAccountMetas;
     private aumRemainingAccounts;
+    /**
+     * Returns the readonly account metas required to recalculate the vault's current tracked AUM.
+     * Extra metas can be appended for pending positions or newly introduced Kamino reserves.
+     */
+    getAumRemainingAccountMetas(extraRemainingAccounts?: AccountMeta[]): AccountMeta[];
+    private ixManagePriceUpdates;
     ixUpdatePrice({ priceInterfaceAccounts, pythPriceFeedId, remainingAccounts, priceId, }: UpdatePriceParams): TransactionInstruction;
     ixsDepositLiquidity({ depositor, mint, tokenAmountIn, minLpOut, tokenSrc, entryTokenVault, tokenLpDst, tokenProgram, extraRemainingAccounts, useLegacyTokenAccounts, }: DepositLiquidityParams): Promise<TransactionInstruction[]>;
     ixQueueWithdrawal({ depositor, lpAmount, tokenLpSrc, tokenProgram, systemProgram, tokenLpEscrow, }: QueueWithdrawalParams): {
@@ -537,6 +578,14 @@ export declare class ExponentVault {
      * Create instruction to call wrapper_manager_update_position.
      */
     ixWrapperManagerUpdatePosition({ manager, update, remainingAccounts, exponentPrices, systemProgram, }: WrapperManagerUpdatePositionParams): TransactionInstruction;
+    /**
+     * Convenience wrapper for adding a tracked Kamino obligation position.
+     */
+    ixWrapperAddKaminoObligationPosition({ manager, obligation, lendingProgramId, quotePriceId, reservePriceMappings, reserveFarmMappings, minPriceStatusFlags, remainingAccounts, exponentPrices, systemProgram, }: WrapperAddKaminoObligationPositionParams): TransactionInstruction;
+    /**
+     * Convenience wrapper for updating tracked reserve price mappings on a Kamino obligation.
+     */
+    ixWrapperUpsertKaminoObligationReservePriceMappings({ manager, obligation, reservePriceMappings, reserveFarmMappings, remainingAccounts, exponentPrices, systemProgram, }: WrapperUpsertKaminoObligationReservePriceMappingsParams): TransactionInstruction;
     /**
      * Create instruction to add a policy to this vault.
      * Direct policy management requires an empty vault; live vaults must use proposals.
@@ -596,7 +645,7 @@ export declare class ExponentVault {
      * Requires an RPC endpoint that supports the `simulateBundle` method (e.g., Jito, Helius).
      */
     getTotalAumViaJitoBundle(pricesAccount: ExponentPrices, jitoBundleRpc?: string): Promise<bigint>;
-    ixsUpdateStrategyVaultPrices(pricesAccount: ExponentPrices): Promise<TransactionInstruction[]>;
+    ixsUpdateStrategyVaultPrices(pricesAccount: ExponentPrices, options?: UpdateStrategyVaultPricesOptions): Promise<TransactionInstruction[]>;
     /**
      * Converts vault `PolicyConfig` (policyType shape from policy builders) to the Codama/client codec shape
      * required by the proposal action codecs used by staged proposal creation.

package/build/exponentVaults/vault.js

@@ -26,14 +26,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExponentVault = exports.getSyntheticMintDecimals = exports.SYNTHETIC_USD9_DECIMALS = exports.SYNTHETIC_USD9_MINT = exports.SYNTHETIC_USD_DECIMALS = exports.SYNTHETIC_USD_MINT = void 0;
+exports.ExponentVault = exports.collectTrackedStrategyVaultPriceIds = exports.getSyntheticMintDecimals = exports.SYNTHETIC_USD9_DECIMALS = exports.SYNTHETIC_USD9_MINT = exports.SYNTHETIC_USD_DECIMALS = exports.SYNTHETIC_USD_MINT = void 0;
 // The following methods have breaking changes: ixDepositLiquidity, ixQueueWithdrawal, ixExecuteWithdrawal, ixManagerRefreshSyRate
 // Account names changed: tokenSySrc -> tokenSrc, tokenSyVault -> entryTokenVault
 // New required accounts: exponentPrices
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const bs58_1 = __importDefault(require("bs58"));
-const exponent_vaults_fetcher_1 = require("@exponent-labs/exponent-vaults-fetcher");
 const exponent_vaults_idl_1 = require("@exponent-labs/exponent-vaults-idl");
 const exponent_vaults_pda_1 = require("@exponent-labs/exponent-vaults-pda");
 const marketThree_1 = require("../client/clmm/accounts/marketThree");
@@ -41,11 +40,17 @@ const exponentVaults = __importStar(require("../client/vaults"));
 const environment_1 = require("../environment");
 const utils_1 = require("../utils");
 const aumCalculator_1 = require("./aumCalculator");
+const fetcher_1 = require("./fetcher");
+const kamino_farms_1 = require("./kamino-farms");
+const pricePathResolver_1 = require("./pricePathResolver");
 const squadsVaultTxnResolver_1 = require("./squadsVaultTxnResolver");
+const constants_1 = require("./../../../kamino-lend-standard/src/constants");
 exports.SYNTHETIC_USD_MINT = new web3_js_1.PublicKey("USD1111111111111111111111111111111111111111");
 exports.SYNTHETIC_USD_DECIMALS = 6;
 exports.SYNTHETIC_USD9_MINT = new web3_js_1.PublicKey("USD1111111111111111111111111111111111111119");
 exports.SYNTHETIC_USD9_DECIMALS = 9;
+const LOCAL_UPDATE_PRICE_DISCRIMINATOR = Buffer.from([7]);
+const KAMINO_FARMS_PROGRAM_ID = new web3_js_1.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
 const getSyntheticMintDecimals = (mint) => {
     if (mint.equals(exports.SYNTHETIC_USD_MINT))
         return exports.SYNTHETIC_USD_DECIMALS;
@@ -54,6 +59,82 @@ const getSyntheticMintDecimals = (mint) => {
     return null;
 };
 exports.getSyntheticMintDecimals = getSyntheticMintDecimals;
+function unwrapTupleLikeValue(value) {
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    if (value && typeof value === "object" && "0" in value) {
+        return value[0];
+    }
+    return value ?? undefined;
+}
+function addTrackedPriceIds(target, priceIdValue) {
+    for (const id of (0, pricePathResolver_1.extractPriceIds)(priceIdValue)) {
+        const numericId = Number(id);
+        if (numericId !== 0) {
+            target.add(numericId);
+        }
+    }
+}
+function collectTrackedStrategyVaultPriceIds(state) {
+    const allPriceIds = new Set();
+    for (const entry of state.tokenEntries) {
+        addTrackedPriceIds(allPriceIds, entry.priceId);
+    }
+    for (const position of state.strategyPositions) {
+        if ("orderbook" in position) {
+            const orderbook = unwrapTupleLikeValue(position.orderbook);
+            if (orderbook?.priceIdPt) {
+                addTrackedPriceIds(allPriceIds, orderbook.priceIdPt);
+            }
+            continue;
+        }
+        if ("tokenAccount" in position) {
+            const tokenAccount = unwrapTupleLikeValue(position.tokenAccount);
+            for (const balance of tokenAccount?.balances ?? []) {
+                if (balance.priceId) {
+                    addTrackedPriceIds(allPriceIds, balance.priceId);
+                }
+            }
+            continue;
+        }
+        if ("yieldPosition" in position) {
+            const yieldPosition = unwrapTupleLikeValue(position.yieldPosition);
+            if (yieldPosition?.priceIdPt) {
+                addTrackedPriceIds(allPriceIds, yieldPosition.priceIdPt);
+            }
+            continue;
+        }
+        if ("clmmPosition" in position) {
+            const clmmPosition = unwrapTupleLikeValue(position.clmmPosition);
+            if (clmmPosition?.priceIdPt) {
+                addTrackedPriceIds(allPriceIds, clmmPosition.priceIdPt);
+            }
+            if (clmmPosition?.priceIdSy) {
+                addTrackedPriceIds(allPriceIds, clmmPosition.priceIdSy);
+            }
+            continue;
+        }
+        if ("obligation" in position) {
+            const rawObligation = position.obligation;
+            const inner = unwrapTupleLikeValue(rawObligation);
+            const kaminoVariant = inner && typeof inner === "object" && "kaminoObligation" in inner
+                ? inner.kaminoObligation
+                : inner;
+            const kaminoEntry = unwrapTupleLikeValue(kaminoVariant);
+            if (kaminoEntry?.quotePriceId) {
+                addTrackedPriceIds(allPriceIds, kaminoEntry.quotePriceId);
+            }
+            for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
+                if (mapping.reservePriceId) {
+                    addTrackedPriceIds(allPriceIds, mapping.reservePriceId);
+                }
+            }
+        }
+    }
+    return allPriceIds;
+}
+exports.collectTrackedStrategyVaultPriceIds = collectTrackedStrategyVaultPriceIds;
 const getMintDecimals = async (connection, mint) => {
     const syntheticDecimals = (0, exports.getSyntheticMintDecimals)(mint);
     if (syntheticDecimals !== null) {
@@ -67,6 +148,15 @@ const pushPriceMintAccount = (remainingAccounts, mint) => {
         return;
     remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: false });
 };
+const isLocalRpcEndpoint = (rpcEndpoint) => {
+    try {
+        const hostname = new URL(rpcEndpoint).hostname;
+        return hostname === "127.0.0.1" || hostname === "localhost";
+    }
+    catch {
+        return rpcEndpoint.includes("127.0.0.1") || rpcEndpoint.includes("localhost");
+    }
+};
 const VAULT_SEED = Buffer.from("vault");
 const toBigInt = (value) => {
     if (typeof value === "bigint")
@@ -241,6 +331,8 @@ class ExponentVault {
     pda;
     aumCalculator;
     clmmTicksMap = new Map();
+    kaminoFarmAuxAccountsMap = new Map();
+    kaminoObligationFarmUserStates = new Set();
     static squadsVaultTxnResolver = new squadsVaultTxnResolver_1.SquadsVaultTxnResolver();
     constructor(params) {
         this.state = params.state;
@@ -248,13 +340,13 @@ class ExponentVault {
         this.env = params.env ?? environment_1.LOCAL_ENV;
         this.connection = params.connection;
         this.programId = params.programId ?? this.env.exponentVaultsProgramId ?? new web3_js_1.PublicKey(exponent_vaults_idl_1.PROGRAM_ID);
-        this.fetcher = new exponent_vaults_fetcher_1.ExponentVaultsFetcher(this.connection, this.programId);
+        this.fetcher = new fetcher_1.ExponentVaultsFetcher(this.connection, this.programId);
         this.pda = new exponent_vaults_pda_1.ExponentVaultsPDA(this.programId);
         this.aumCalculator = new aumCalculator_1.AumCalculator(this.state, this.connection, this.env);
     }
     static async load(params) {
         const env = params.env ?? environment_1.LOCAL_ENV;
-        const fetcher = new exponent_vaults_fetcher_1.ExponentVaultsFetcher(params.connection, env.exponentVaultsProgramId ?? exponent_vaults_idl_1.PROGRAM_ID);
+        const fetcher = new fetcher_1.ExponentVaultsFetcher(params.connection, env.exponentVaultsProgramId ?? exponent_vaults_idl_1.PROGRAM_ID);
         const state = await fetcher.fetchVaultDeserialized(params.address);
         const vault = new ExponentVault({
             state,
@@ -263,12 +355,15 @@ class ExponentVault {
             connection: params.connection,
             programId: fetcher.programId,
         });
-        await vault.populateClmmTicksCache(params.connection);
+        await Promise.all([
+            vault.populateClmmTicksCache(params.connection),
+            vault.populateKaminoFarmAuxAccountsCache(params.connection),
+        ]);
         return vault;
     }
     static async loadAll(params) {
         const env = params.env ?? environment_1.LOCAL_ENV;
-        const fetcher = new exponent_vaults_fetcher_1.ExponentVaultsFetcher(params.connection, env.exponentVaultsProgramId ?? exponent_vaults_idl_1.PROGRAM_ID);
+        const fetcher = new fetcher_1.ExponentVaultsFetcher(params.connection, env.exponentVaultsProgramId ?? exponent_vaults_idl_1.PROGRAM_ID);
         const vaults = await fetcher.fetchAllVaultsDeserialized();
         const results = vaults.map(({ publicKey, account }) => new ExponentVault({
             state: account,
@@ -277,13 +372,18 @@ class ExponentVault {
             connection: params.connection,
             programId: fetcher.programId,
         }));
-        await Promise.all(results.map((v) => v.populateClmmTicksCache(params.connection)));
+        await Promise.all(results.flatMap((vault) => [
+            vault.populateClmmTicksCache(params.connection),
+            vault.populateKaminoFarmAuxAccountsCache(params.connection),
+        ]));
         return results;
     }
     async reload(connection = this.connection) {
         const refreshed = await ExponentVault.load({ env: this.env, connection, address: this.selfAddress });
         this.state = refreshed.state;
         this.clmmTicksMap = refreshed.clmmTicksMap;
+        this.kaminoFarmAuxAccountsMap = refreshed.kaminoFarmAuxAccountsMap;
+        this.kaminoObligationFarmUserStates = refreshed.kaminoObligationFarmUserStates;
         this.connection = connection;
         this.aumCalculator = new aumCalculator_1.AumCalculator(this.state, this.connection, this.env);
         return refreshed;
@@ -309,6 +409,90 @@ class ExponentVault {
             }
         }
     }
+    async populateKaminoFarmAuxAccountsCache(connection) {
+        this.kaminoFarmAuxAccountsMap.clear();
+        this.kaminoObligationFarmUserStates.clear();
+        const farmStates = [];
+        const delegatedFarmUsers = [];
+        for (const pos of this.state.strategyPositions) {
+            if ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
+                const entry = pos.kaminoFarm[0];
+                if (!farmStates.some((farmState) => farmState.equals(entry.farmState))) {
+                    farmStates.push(entry.farmState);
+                }
+                continue;
+            }
+            if (!("obligation" in pos) || !pos.obligation || typeof pos.obligation !== "object") {
+                continue;
+            }
+            const rawObligation = pos["obligation"];
+            const inner = Array.isArray(rawObligation)
+                ? rawObligation[0]
+                : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
+                    ? rawObligation[0]
+                    : rawObligation;
+            const kaminoVariant = inner && "kaminoObligation" in inner ? inner.kaminoObligation : inner;
+            const entry = Array.isArray(kaminoVariant)
+                ? kaminoVariant[0]
+                : kaminoVariant && typeof kaminoVariant === "object" && "0" in kaminoVariant
+                    ? (kaminoVariant[0] ?? undefined)
+                    : kaminoVariant;
+            if (!(entry?.obligation instanceof web3_js_1.PublicKey)) {
+                continue;
+            }
+            for (const mapping of entry.reserveFarmMappings ?? []) {
+                if (!farmStates.some((farmState) => farmState.equals(mapping.farmState))) {
+                    farmStates.push(mapping.farmState);
+                }
+                delegatedFarmUsers.push({
+                    obligation: entry.obligation,
+                    farmState: mapping.farmState,
+                    userState: (0, constants_1.getKaminoFarmsObligationFarm)(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
+                });
+            }
+        }
+        if (farmStates.length === 0) {
+            return;
+        }
+        const farmInfos = await connection.getMultipleAccountsInfo(farmStates);
+        for (const [index, farmInfo] of farmInfos.entries()) {
+            const farmState = farmStates[index];
+            if (!farmState || !farmInfo?.data) {
+                if (ExponentVault.debugAum && farmState) {
+                    console.log("[VAULT_AUM] kaminoFarmAux: missing farm info", farmState.toBase58());
+                }
+                continue;
+            }
+            const farm = (0, kamino_farms_1.decodeKaminoFarmState)(Buffer.from(farmInfo.data));
+            const auxAccounts = [{ pubkey: farm.globalConfig, isSigner: false, isWritable: false }];
+            const scopePrices = (0, kamino_farms_1.getKaminoFarmScopePricesAddress)(farm);
+            if (scopePrices) {
+                auxAccounts.push({ pubkey: scopePrices, isSigner: false, isWritable: false });
+            }
+            this.kaminoFarmAuxAccountsMap.set(farmState.toBase58(), auxAccounts);
+            if (ExponentVault.debugAum) {
+                console.log("[VAULT_AUM] kaminoFarmAux:", farmState.toBase58(), auxAccounts.map((account) => account.pubkey.toBase58()).join(", "));
+            }
+        }
+        if (delegatedFarmUsers.length === 0) {
+            return;
+        }
+        const uniqueUsers = Array.from(new Map(delegatedFarmUsers.map((entry) => [
+            `${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`,
+            entry,
+        ])).values());
+        const userInfos = await connection.getMultipleAccountsInfo(uniqueUsers.map((entry) => entry.userState));
+        for (const [index, userInfo] of userInfos.entries()) {
+            if (!userInfo?.data) {
+                continue;
+            }
+            const entry = uniqueUsers[index];
+            if (!entry) {
+                continue;
+            }
+            this.kaminoObligationFarmUserStates.add(`${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`);
+        }
+    }
     /**
      * Derive the PDA for a vault using its 8-byte seed identifier.
      */
@@ -386,7 +570,12 @@ class ExponentVault {
                 }
             }
             else if ("obligation" in pos && pos.obligation && typeof pos.obligation === "object") {
-                const inner = pos["obligation"][0];
+                const rawObligation = pos["obligation"];
+                const inner = Array.isArray(rawObligation)
+                    ? rawObligation[0]
+                    : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
+                        ? rawObligation[0]
+                        : rawObligation;
                 const kaminoVariant = inner && "kaminoObligation" in inner ? inner.kaminoObligation : inner;
                 const entry = Array.isArray(kaminoVariant)
                     ? kaminoVariant[0]
@@ -406,11 +595,30 @@ class ExponentVault {
                             isWritable: false,
                         });
                     }
+                    for (const mapping of entry.reserveFarmMappings ?? []) {
+                        metas.push({
+                            pubkey: mapping.farmState,
+                            isSigner: false,
+                            isWritable: false,
+                        });
+                        const obligationFarmUserKey = `${entry.obligation.toBase58()}:${mapping.farmState.toBase58()}`;
+                        if (this.kaminoObligationFarmUserStates.has(obligationFarmUserKey)) {
+                            metas.push({
+                                pubkey: (0, constants_1.getKaminoFarmsObligationFarm)(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
+                                isSigner: false,
+                                isWritable: false,
+                            });
+                        }
+                        metas.push(...(this.kaminoFarmAuxAccountsMap.get(mapping.farmState.toBase58()) ?? []));
+                    }
                     if (ExponentVault.debugAum) {
                         console.log("[VAULT_AUM] strategyPosition: Obligation", entry.obligation.toBase58());
                         for (const mapping of entry.reservePriceMappings ?? []) {
                             console.log("[VAULT_AUM] strategyPosition: Kamino reserve", mapping.reserve.toBase58());
                         }
+                        for (const mapping of entry.reserveFarmMappings ?? []) {
+                            console.log("[VAULT_AUM] strategyPosition: Kamino delegated farm", mapping.farmState.toBase58());
+                        }
                     }
                 }
             }
@@ -454,6 +662,25 @@ class ExponentVault {
                     console.log("[VAULT_AUM] strategyPosition: ClmmPosition", entry.lpPosition.toBase58(), entry.market.toBase58(), ticksKey ? ticksKey.toBase58() : "(ticks not cached)");
                 }
             }
+            else if ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
+                const entry = pos.kaminoFarm[0];
+                metas.push({
+                    pubkey: entry.farmState,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                metas.push({
+                    pubkey: entry.userState,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                const auxAccounts = this.kaminoFarmAuxAccountsMap.get(entry.farmState.toBase58()) ?? [];
+                metas.push(...auxAccounts);
+                if (ExponentVault.debugAum) {
+                    console.log("[VAULT_AUM] strategyPosition: KaminoFarm", entry.farmState.toBase58(), entry.userState.toBase58());
+                    console.log("[VAULT_AUM] strategyPosition: KaminoFarm aux", auxAccounts.map((account) => account.pubkey.toBase58()).join(", ") || "(none)");
+                }
+            }
             else if ("loopscaleStrategy" in pos && pos.loopscaleStrategy && typeof pos.loopscaleStrategy === "object") {
                 const entry = pos.loopscaleStrategy[0];
                 if (entry?.strategy instanceof web3_js_1.PublicKey) {
@@ -502,6 +729,38 @@ class ExponentVault {
     aumRemainingAccounts() {
         return [...this.tokenEntryAccountMetas(), ...this.strategyPositionAccountMetas()];
     }
+    /**
+     * Returns the readonly account metas required to recalculate the vault's current tracked AUM.
+     * Extra metas can be appended for pending positions or newly introduced Kamino reserves.
+     */
+    getAumRemainingAccountMetas(extraRemainingAccounts = []) {
+        return (0, utils_1.uniqueRemainingAccounts)([...this.aumRemainingAccounts(), ...extraRemainingAccounts]);
+    }
+    ixManagePriceUpdates({ manager, updates, }) {
+        if (updates.length === 0) {
+            throw new Error("ixManagePriceUpdates requires at least one update");
+        }
+        const resolvedManager = manager ?? this.state.roles.manager[0];
+        if (!resolvedManager) {
+            throw new Error("Vault manager not found");
+        }
+        const [exponentPrices] = this.pda.exponentPrices();
+        const remainingAccounts = [];
+        const actions = updates.map((update) => {
+            if (!update.priceInterfaceAccounts) {
+                throw new Error(`priceInterfaceAccounts required for priceId ${update.priceId}`);
+            }
+            remainingAccounts.push({ pubkey: update.priceInterfaceAccounts, isSigner: false, isWritable: false });
+            return {
+                __kind: "UpdatePrice",
+                priceId: BigInt(update.priceId),
+                priceType: update.priceType,
+            };
+        });
+        const ix = exponentVaults.createManagePricesInstruction({ manager: resolvedManager, exponentPrices, systemProgram: web3_js_1.SystemProgram.programId }, { actions }, this.programId);
+        ix.keys.push(...remainingAccounts);
+        return ix;
+    }
     ixUpdatePrice({ priceInterfaceAccounts, pythPriceFeedId, remainingAccounts = [], priceId, }) {
         const [exponentPrices] = this.pda.exponentPrices();
         if (!priceInterfaceAccounts) {
@@ -512,8 +771,11 @@ class ExponentVault {
             ...remainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })),
             ...(pythPriceFeedId ? [{ pubkey: pythPriceFeedId, isSigner: false, isWritable: false }] : []),
         ];
-        const ix = exponentVaults.createUpdatePriceInstruction({ exponentPrices }, { updates: [{ priceId: BigInt(priceId), interfaceAccountsIndex: 0 }] });
+        const ix = exponentVaults.createUpdatePriceInstruction({ exponentPrices }, { updates: [{ priceId: BigInt(priceId), interfaceAccountsIndex: 0 }] }, this.programId);
         ix.keys.push(...updateRemainingAccounts);
+        if (isLocalRpcEndpoint(this.connection.rpcEndpoint)) {
+            ix.data = Buffer.concat([LOCAL_UPDATE_PRICE_DISCRIMINATOR, ix.data.subarray(1)]);
+        }
         return ix;
     }
     async ixsDepositLiquidity({ depositor, mint, tokenAmountIn, minLpOut, tokenSrc, entryTokenVault, tokenLpDst, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, extraRemainingAccounts = [], useLegacyTokenAccounts = false, }) {
@@ -522,6 +784,7 @@ class ExponentVault {
         const vault = entryTokenVault ?? entry.tokenSquadsAccount;
         const lpDst = tokenLpDst ?? defaultTokenAccount(this.state.mintLp, depositor, tokenProgram);
         const exponentPrices = this.pda.exponentPrices()[0];
+        const tokenProgramLp = useLegacyTokenAccounts ? spl_token_1.TOKEN_2022_PROGRAM_ID : spl_token_1.TOKEN_PROGRAM_ID;
         const preIxs = [];
         // If depositing WSOL, wrap native SOL as needed
         if (mint.equals(spl_token_1.NATIVE_MINT)) {
@@ -562,7 +825,7 @@ class ExponentVault {
             tokenLpDst: lpDst,
             mintLp: this.state.mintLp,
             tokenProgram,
-            tokenProgramLp: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenProgramLp,
             eventAuthority: this.eventAuthority,
             program: this.programId,
         }, { tokenAmountIn: toBigInt(tokenAmountIn), minLpOut: toBigInt(minLpOut) });
@@ -756,6 +1019,44 @@ class ExponentVault {
         ix.keys.push(...remainingAccounts);
         return ix;
     }
+    /**
+     * Convenience wrapper for adding a tracked Kamino obligation position.
+     */
+    ixWrapperAddKaminoObligationPosition({ manager, obligation, lendingProgramId, quotePriceId, reservePriceMappings, reserveFarmMappings = [], minPriceStatusFlags, remainingAccounts = [], exponentPrices = this.pda.exponentPrices()[0], systemProgram = web3_js_1.SystemProgram.programId, }) {
+        const obligationEntry = {
+            obligation,
+            lendingProgramId,
+            quotePriceId,
+            reservePriceMappings,
+            reserveFarmMappings,
+            minPriceStatusFlags,
+        };
+        return this.ixWrapperManagerUpdatePosition({
+            manager,
+            exponentPrices,
+            systemProgram,
+            remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
+            update: exponentVaults.positionUpdate("AddKaminoObligationEntry", [
+                obligationEntry,
+            ]),
+        });
+    }
+    /**
+     * Convenience wrapper for updating tracked reserve price mappings on a Kamino obligation.
+     */
+    ixWrapperUpsertKaminoObligationReservePriceMappings({ manager, obligation, reservePriceMappings, reserveFarmMappings = [], remainingAccounts = [], exponentPrices = this.pda.exponentPrices()[0], systemProgram = web3_js_1.SystemProgram.programId, }) {
+        return this.ixWrapperManagerUpdatePosition({
+            manager,
+            exponentPrices,
+            systemProgram,
+            remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
+            update: exponentVaults.positionUpdate("UpsertKaminoObligationReservePriceMappings", {
+                obligation,
+                reservePriceMappings,
+                reserveFarmMappings,
+            }),
+        });
+    }
     // ==========================================================================
     // Policy Management Methods
     // ==========================================================================
@@ -1211,8 +1512,7 @@ class ExponentVault {
             if (!postVaultAccountData) {
                 throw new Error("Jito bundle simulation failed");
             }
-            const decoded = this.fetcher.program.account.exponentStrategyVault.coder.accounts.decode("exponentStrategyVault", Buffer.from(postVaultAccountData, "base64"));
-            const vaultStateAfterSimulations = (0, exponent_vaults_fetcher_1.transformAnchorData)(decoded);
+            const vaultStateAfterSimulations = (0, fetcher_1.deserializeExponentStrategyVaultFetcherShape)(Buffer.from(postVaultAccountData, "base64"));
             const aum = vaultStateAfterSimulations.financials.aumInBase + vaultStateAfterSimulations.financials.aumInBaseInPositions;
             return aum;
         }
@@ -1221,51 +1521,27 @@ class ExponentVault {
             return this.getTotalAum();
         }
     }
-    async ixsUpdateStrategyVaultPrices(pricesAccount) {
-        const extractPriceIds = (priceId) => {
-            const ids = "simple" in priceId ? [Number(priceId.simple.priceId)] : priceId.multiply.priceIds.map(Number);
-            return ids.filter((id) => id !== 0); // skip passthrough (price_id 0)
-        };
-        const allPriceIds = new Set();
-        for (const entry of this.state.tokenEntries) {
-            extractPriceIds(entry.priceId).forEach((id) => allPriceIds.add(id));
-        }
-        for (const position of this.state.strategyPositions) {
-            if ("orderbook" in position) {
-                const orderbook = position.orderbook[0];
-                extractPriceIds(orderbook.priceIdPt).forEach((id) => allPriceIds.add(id));
-                continue;
-            }
-            if ("tokenAccount" in position) {
-                for (const balance of position.tokenAccount[0].balances) {
-                    extractPriceIds(balance.priceId).forEach((id) => allPriceIds.add(id));
-                }
-                continue;
-            }
-            if ("obligation" in position) {
-                const inner = position.obligation[0];
-                const kaminoEntry = inner && typeof inner === "object" && "kaminoObligation" in inner ? inner.kaminoObligation?.[0] : inner?.[0];
-                if (kaminoEntry?.quotePriceId) {
-                    extractPriceIds(kaminoEntry.quotePriceId).forEach((id) => allPriceIds.add(id));
-                }
-                for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
-                    if (mapping.reservePriceId) {
-                        extractPriceIds(mapping.reservePriceId).forEach((id) => allPriceIds.add(id));
-                    }
-                }
-            }
+    async ixsUpdateStrategyVaultPrices(pricesAccount, options = {}) {
+        const trackedPriceIds = options.priceIds ??
+            collectTrackedStrategyVaultPriceIds({
+                tokenEntries: this.state.tokenEntries,
+                strategyPositions: this.state.strategyPositions,
+            });
+        const priceIds = [...trackedPriceIds].sort((a, b) => a - b);
+        if (priceIds.length === 0) {
+            return [];
         }
-        return Promise.all([...allPriceIds].map((priceId) => {
+        return priceIds.map((priceId) => {
             const priceEntry = pricesAccount.prices[priceId];
             if (!priceEntry) {
                 throw new Error(`Price entry not found for priceId ${priceId}`);
             }
             return this.ixUpdatePrice({
+                priceId,
                 priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
                 remainingAccounts: priceEntry.interfaceAccounts,
-                priceId,
             });
-        }));
+        });
     }
     // ==========================================================================
     // Helper Methods — Codama type conversions