@exponent-labs/exponent-sdk 0.1.8 → 0.9.1

package/build/exponentVaults/vault.js

@@ -0,0 +1,1713 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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_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");
+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;
+    if (mint.equals(exports.SYNTHETIC_USD9_MINT))
+        return exports.SYNTHETIC_USD9_DECIMALS;
+    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) {
+        return syntheticDecimals;
+    }
+    const mintInfo = await (0, spl_token_1.getMint)(connection, mint);
+    return mintInfo.decimals;
+};
+const pushPriceMintAccount = (remainingAccounts, mint) => {
+    if ((0, exports.getSyntheticMintDecimals)(mint) !== null)
+        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")
+        return value;
+    return BigInt(Math.ceil(value));
+};
+const toCodamaPriceId = (priceId) => {
+    if ("simple" in priceId) {
+        return {
+            __kind: "Simple",
+            priceId: toBigInt(priceId.simple.priceId),
+        };
+    }
+    if ("multiply" in priceId) {
+        return {
+            __kind: "Multiply",
+            priceIds: priceId.multiply.priceIds.map((id) => toBigInt(id)),
+        };
+    }
+    throw new Error("Unknown PriceId variant");
+};
+const defaultTokenAccount = (mint, owner, tokenProgram) => (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, true, tokenProgram);
+const PRICE_INTERFACE_ACCOUNTS_SEED = Buffer.from("price_interface_accounts");
+const randomPriceInterfaceAccountsSeed = () => Uint8Array.from(web3_js_1.Keypair.generate().publicKey.toBytes().slice(0, 8));
+const derivePriceInterfaceAccountsAddress = (programId, exponentPrices, seed) => web3_js_1.PublicKey.findProgramAddressSync([PRICE_INTERFACE_ACCOUNTS_SEED, exponentPrices.toBuffer(), Buffer.from(seed)], programId);
+const convertPriceType = (priceType) => {
+    if ("pyth" in priceType)
+        return exponentVaults.PriceType.Pyth;
+    if ("pythInverse" in priceType)
+        return exponentVaults.PriceType.PythInverse;
+    if ("splStakePool" in priceType)
+        return exponentVaults.PriceType.SplStakePool;
+    if ("one" in priceType)
+        return exponentVaults.PriceType.One;
+    if ("pt" in priceType)
+        return exponentVaults.PriceType.Pt;
+    if ("yt" in priceType)
+        return exponentVaults.PriceType.Yt;
+    if ("solstice" in priceType)
+        return exponentVaults.PriceType.Solstice;
+    if ("reflect" in priceType)
+        return exponentVaults.PriceType.Reflect;
+    if ("fragmetric" in priceType)
+        return exponentVaults.PriceType.Fragmetric;
+    if ("fragmetricSupportedAsset" in priceType)
+        return exponentVaults.PriceType.FragmetricSupportedAsset;
+    if ("jupiterLend" in priceType)
+        return exponentVaults.PriceType.JupiterLend;
+    if ("chainlink" in priceType)
+        return exponentVaults.PriceType.Chainlink;
+    if ("ore" in priceType)
+        return exponentVaults.PriceType.Ore;
+    if ("hyloLpToken" in priceType)
+        return exponentVaults.PriceType.HyloLpToken;
+    if ("meteora" in priceType)
+        return exponentVaults.PriceType.Meteora;
+    if ("kaminoVault" in priceType)
+        return exponentVaults.PriceType.KaminoVault;
+    throw new Error("Unknown PriceType variant");
+};
+const convertUpdatePriceAction = (action, programId, exponentPrices, remainingAccounts) => {
+    if ("addPrice" in action) {
+        const seed = randomPriceInterfaceAccountsSeed();
+        const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed);
+        const interfaceAccounts = action.addPrice.interfaceAccounts ?? [];
+        remainingAccounts.push({
+            pubkey: priceInterfaceAccounts,
+            isSigner: false,
+            isWritable: true,
+        });
+        pushPriceMintAccount(remainingAccounts, action.addPrice.priceMint);
+        pushPriceMintAccount(remainingAccounts, action.addPrice.underlyingMint);
+        return {
+            __kind: "AddPrice",
+            priceType: convertPriceType(action.addPrice.priceType),
+            priceMint: action.addPrice.priceMint,
+            underlyingMint: action.addPrice.underlyingMint,
+            interfaceAccounts,
+            priceInterfaceAccountsSeed: seed,
+        };
+    }
+    if ("removePrice" in action) {
+        if (!action.removePrice.priceInterfaceAccounts) {
+            throw new Error("removePrice requires priceInterfaceAccounts");
+        }
+        remainingAccounts.push({
+            pubkey: action.removePrice.priceInterfaceAccounts,
+            isSigner: false,
+            isWritable: true,
+        });
+        return {
+            __kind: "RemovePrice",
+            priceId: toBigInt(action.removePrice.priceId),
+        };
+    }
+    if ("updatePrice" in action) {
+        if (!action.updatePrice.priceInterfaceAccounts) {
+            throw new Error("updatePrice requires priceInterfaceAccounts");
+        }
+        remainingAccounts.push({
+            pubkey: action.updatePrice.priceInterfaceAccounts,
+            isSigner: false,
+            isWritable: false,
+        });
+        return {
+            __kind: "UpdatePrice",
+            priceId: toBigInt(action.updatePrice.priceId),
+            priceType: convertPriceType(action.updatePrice.priceType),
+        };
+    }
+    if ("addManager" in action) {
+        return {
+            __kind: "AddManager",
+            manager: action.addManager.manager,
+        };
+    }
+    if ("removeManager" in action) {
+        return {
+            __kind: "RemoveManager",
+            manager: action.removeManager.manager,
+        };
+    }
+    if ("addPtPrice" in action) {
+        const seed = randomPriceInterfaceAccountsSeed();
+        const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed);
+        const interfaceAccounts = action.addPtPrice.interfaceAccounts ?? [];
+        remainingAccounts.push({
+            pubkey: priceInterfaceAccounts,
+            isSigner: false,
+            isWritable: true,
+        });
+        pushPriceMintAccount(remainingAccounts, action.addPtPrice.priceMint);
+        pushPriceMintAccount(remainingAccounts, action.addPtPrice.underlyingMint);
+        return {
+            __kind: "AddPtPrice",
+            priceMint: action.addPtPrice.priceMint,
+            underlyingMint: action.addPtPrice.underlyingMint,
+            interfaceAccounts,
+            priceInterfaceAccountsSeed: seed,
+            impliedApyBps: action.addPtPrice.impliedApyBps,
+        };
+    }
+    if ("addYtPrice" in action) {
+        const seed = randomPriceInterfaceAccountsSeed();
+        const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed);
+        const interfaceAccounts = action.addYtPrice.interfaceAccounts ?? [];
+        remainingAccounts.push({
+            pubkey: priceInterfaceAccounts,
+            isSigner: false,
+            isWritable: true,
+        });
+        pushPriceMintAccount(remainingAccounts, action.addYtPrice.priceMint);
+        pushPriceMintAccount(remainingAccounts, action.addYtPrice.underlyingMint);
+        return {
+            __kind: "AddYtPrice",
+            priceMint: action.addYtPrice.priceMint,
+            underlyingMint: action.addYtPrice.underlyingMint,
+            interfaceAccounts,
+            priceInterfaceAccountsSeed: seed,
+            impliedApyBps: action.addYtPrice.impliedApyBps,
+        };
+    }
+    throw new Error("Unknown UpdatePriceAction variant");
+};
+class ExponentVault {
+    state;
+    selfAddress;
+    env;
+    connection;
+    programId;
+    fetcher;
+    pda;
+    aumCalculator;
+    clmmTicksMap = new Map();
+    kaminoFarmAuxAccountsMap = new Map();
+    kaminoObligationFarmUserStates = new Set();
+    static squadsVaultTxnResolver = new squadsVaultTxnResolver_1.SquadsVaultTxnResolver();
+    constructor(params) {
+        this.state = params.state;
+        this.selfAddress = params.address;
+        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 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 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,
+            address: params.address,
+            env,
+            connection: params.connection,
+            programId: fetcher.programId,
+        });
+        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 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,
+            address: publicKey,
+            env,
+            connection: params.connection,
+            programId: fetcher.programId,
+        }));
+        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;
+    }
+    async populateClmmTicksCache(connection) {
+        this.clmmTicksMap.clear();
+        const marketKeys = [];
+        for (const pos of this.state.strategyPositions) {
+            if ("clmmPosition" in pos && pos.clmmPosition && typeof pos.clmmPosition === "object") {
+                const entry = pos.clmmPosition[0];
+                const key = entry.market.toBase58();
+                if (!this.clmmTicksMap.has(key) && !marketKeys.some((k) => k.equals(entry.market))) {
+                    marketKeys.push(entry.market);
+                }
+            }
+        }
+        if (marketKeys.length === 0)
+            return;
+        const markets = await (0, marketThree_1.fetchAllMaybeMarketThreeAccounts)(connection, marketKeys);
+        for (const market of markets) {
+            if (market) {
+                this.clmmTicksMap.set(market.address.toBase58(), market.data.ticks);
+            }
+        }
+    }
+    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.
+     */
+    static deriveVaultAddress(seedId, programId = new web3_js_1.PublicKey(exponent_vaults_idl_1.PROGRAM_ID)) {
+        if (seedId.length !== 8) {
+            throw new Error(`seedId must contain 8 bytes, received ${seedId.length}`);
+        }
+        const seedBuffer = Buffer.from(seedId);
+        return web3_js_1.PublicKey.findProgramAddressSync([VAULT_SEED, seedBuffer], programId);
+    }
+    get mintLp() {
+        return this.state.mintLp;
+    }
+    get tokenLpEscrow() {
+        return this.state.tokenLpEscrow;
+    }
+    get eventAuthority() {
+        return (0, utils_1.emitEventAuthority)(this.programId);
+    }
+    getTokenEntryOrThrow(mint) {
+        const entry = this.state.tokenEntries.find((e) => e.mint.equals(mint));
+        if (!entry) {
+            throw new Error(`Token entry not found for mint ${mint.toBase58()}`);
+        }
+        return entry;
+    }
+    async fetchWithdrawalAccount(address) {
+        return this.fetcher.fetchWithdrawalAccountDeserialized(address);
+    }
+    async fetchAllActionProposals() {
+        const accounts = await this.connection.getProgramAccounts(this.programId, {
+            filters: [
+                { memcmp: { offset: 0, bytes: bs58_1.default.encode(Buffer.from([144, 192, 194, 210, 241, 173, 240, 41])) } },
+                { memcmp: { offset: 8, bytes: this.selfAddress.toBase58() } },
+            ],
+        });
+        return accounts.map(({ pubkey, account }) => ({
+            address: pubkey,
+            data: exponentVaults.deserializeActionProposalAccount(account.data),
+        }));
+    }
+    async fetchLpTokenSupply() {
+        const { supply } = await (0, spl_token_1.getMint)(this.connection, this.state.mintLp);
+        return supply;
+    }
+    /** Set DEBUG_VAULT_AUM=1 to log AUM remaining accounts (token entries + strategy positions) for debugging */
+    static get debugAum() {
+        return typeof process !== "undefined" && process.env?.DEBUG_VAULT_AUM === "1";
+    }
+    strategyPositionAccountMetas() {
+        const metas = [];
+        for (const pos of this.state.strategyPositions) {
+            if ("orderbook" in pos && pos.orderbook && typeof pos.orderbook === "object") {
+                const entry = pos["orderbook"][0];
+                metas.push({
+                    pubkey: entry.orderbook,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                if (ExponentVault.debugAum) {
+                    console.log("[VAULT_AUM] strategyPosition: Orderbook", entry.orderbook.toBase58());
+                }
+            }
+            else if ("tokenAccount" in pos && pos.tokenAccount && typeof pos.tokenAccount === "object") {
+                const entry = pos["tokenAccount"][0];
+                for (const balance of entry.balances) {
+                    metas.push({
+                        pubkey: balance.tokenAccount,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    if (ExponentVault.debugAum) {
+                        console.log("[VAULT_AUM] strategyPosition: TokenAccount balance", balance.tokenAccount.toBase58());
+                    }
+                }
+            }
+            else if ("obligation" in pos && pos.obligation && typeof pos.obligation === "object") {
+                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) {
+                    metas.push({
+                        pubkey: entry.obligation,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    for (const mapping of entry.reservePriceMappings ?? []) {
+                        metas.push({
+                            pubkey: mapping.reserve,
+                            isSigner: false,
+                            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());
+                        }
+                    }
+                }
+            }
+            else if ("yieldPosition" in pos && pos.yieldPosition && typeof pos.yieldPosition === "object") {
+                const entry = pos["yieldPosition"][0];
+                metas.push({
+                    pubkey: entry.yieldPosition,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                metas.push({
+                    pubkey: entry.vault,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                if (ExponentVault.debugAum) {
+                    console.log("[VAULT_AUM] strategyPosition: YieldPosition", entry.yieldPosition.toBase58(), entry.vault.toBase58(), "(must exist and have exponent_core YieldTokenPosition discriminator)");
+                }
+            }
+            else if ("clmmPosition" in pos && pos.clmmPosition && typeof pos.clmmPosition === "object") {
+                const entry = pos.clmmPosition[0];
+                metas.push({
+                    pubkey: entry.lpPosition,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                metas.push({
+                    pubkey: entry.market,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                const ticksKey = this.clmmTicksMap.get(entry.market.toBase58());
+                if (ticksKey) {
+                    metas.push({
+                        pubkey: ticksKey,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+                if (ExponentVault.debugAum) {
+                    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) {
+                    metas.push({
+                        pubkey: entry.strategy,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    if (ExponentVault.debugAum) {
+                        console.log("[VAULT_AUM] strategyPosition: LoopscaleStrategy", entry.strategy.toBase58());
+                    }
+                }
+            }
+            else if ("loopscaleLoan" in pos && pos.loopscaleLoan && typeof pos.loopscaleLoan === "object") {
+                const entry = pos.loopscaleLoan[0];
+                if (entry?.loan instanceof web3_js_1.PublicKey) {
+                    metas.push({
+                        pubkey: entry.loan,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    if (ExponentVault.debugAum) {
+                        console.log("[VAULT_AUM] strategyPosition: LoopscaleLoan", entry.loan.toBase58());
+                    }
+                }
+            }
+            else if (ExponentVault.debugAum) {
+                console.log("[VAULT_AUM] strategyPosition: UNMATCHED", JSON.stringify(Object.keys(pos)));
+            }
+        }
+        return metas;
+    }
+    tokenEntryAccountMetas() {
+        const metas = this.state.tokenEntries.map((entry) => ({
+            pubkey: entry.tokenSquadsAccount,
+            isSigner: false,
+            isWritable: false,
+        }));
+        if (ExponentVault.debugAum) {
+            metas.forEach((m, i) => {
+                console.log(`[VAULT_AUM] tokenEntry[${i}]:`, m.pubkey.toBase58(), "(vault ATA for mint, must be SPL token account)");
+            });
+        }
+        return metas;
+    }
+    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) {
+            throw new Error("ixUpdatePrice requires priceInterfaceAccounts");
+        }
+        const updateRemainingAccounts = [
+            { pubkey: priceInterfaceAccounts, isSigner: false, isWritable: false },
+            ...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 }] }, 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, }) {
+        const entry = this.getTokenEntryOrThrow(mint);
+        const source = tokenSrc ?? defaultTokenAccount(mint, depositor, tokenProgram);
+        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)) {
+            const wsolAta = (0, spl_token_1.getAssociatedTokenAddressSync)(spl_token_1.NATIVE_MINT, depositor, false, tokenProgram);
+            // Create WSOL ATA (idempotent — no-op if already exists)
+            preIxs.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, wsolAta, depositor, spl_token_1.NATIVE_MINT, tokenProgram));
+            // Check existing WSOL balance
+            let existingWsolBalance = BigInt(0);
+            try {
+                const wsolAccount = await (0, spl_token_1.getAccount)(this.connection, wsolAta, "confirmed", tokenProgram);
+                existingWsolBalance = wsolAccount.amount;
+            }
+            catch {
+                // Account doesn't exist yet — balance is 0
+            }
+            const totalNeeded = toBigInt(tokenAmountIn);
+            if (totalNeeded > existingWsolBalance) {
+                const wrapAmount = totalNeeded - existingWsolBalance;
+                // Transfer native SOL to the WSOL ATA
+                preIxs.push(web3_js_1.SystemProgram.transfer({
+                    fromPubkey: depositor,
+                    toPubkey: wsolAta,
+                    lamports: wrapAmount,
+                }));
+                // Sync the native balance so the token account reflects the deposited SOL
+                preIxs.push((0, spl_token_1.createSyncNativeInstruction)(wsolAta, tokenProgram));
+            }
+        }
+        const depositorLpAta = (0, spl_token_1.getAssociatedTokenAddressSync)(this.state.mintLp, depositor);
+        const createLpAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, depositorLpAta, depositor, this.state.mintLp);
+        const depositIx = exponentVaults.createDepositLiquidityInstruction({
+            depositor,
+            vault: this.selfAddress,
+            exponentPrices,
+            mint,
+            tokenSrc: source,
+            entryTokenVault: vault,
+            tokenLpDst: lpDst,
+            mintLp: this.state.mintLp,
+            tokenProgram,
+            tokenProgramLp,
+            eventAuthority: this.eventAuthority,
+            program: this.programId,
+        }, { tokenAmountIn: toBigInt(tokenAmountIn), minLpOut: toBigInt(minLpOut) });
+        const remainingAccounts = [...this.aumRemainingAccounts(), ...extraRemainingAccounts];
+        depositIx.keys.push(...remainingAccounts);
+        if (ExponentVault.debugAum) {
+            console.log("[VAULT_AUM] ixsDepositLiquidity: total remaining_accounts =", remainingAccounts.length);
+            remainingAccounts.forEach((acc, i) => {
+                console.log(`  [${i}] ${acc.pubkey.toBase58()} writable=${acc.isWritable} signer=${acc.isSigner}`);
+            });
+            console.log("[VAULT_AUM] DepositLiquidity expects: token_entry ATAs (for AUM) + strategy accounts (orderbook, yieldPosition). AccountDiscriminatorNotFound (0xbb9) = wrong account type at one of these.");
+        }
+        return [...preIxs, createLpAtaIx, depositIx];
+    }
+    ixQueueWithdrawal({ depositor, lpAmount, tokenLpSrc, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, systemProgram = web3_js_1.SystemProgram.programId, tokenLpEscrow = this.state.tokenLpEscrow, }) {
+        const withdrawalKeypair = web3_js_1.Keypair.generate();
+        const lpSrc = tokenLpSrc ?? defaultTokenAccount(this.state.mintLp, depositor, tokenProgram);
+        const ix = exponentVaults.createQueueWithdrawalInstruction({
+            depositor,
+            vault: this.selfAddress,
+            withdrawalAccount: withdrawalKeypair.publicKey,
+            tokenLpSrc: lpSrc,
+            tokenLpEscrow,
+            tokenProgram,
+            systemProgram,
+        }, {
+            lpAmount: toBigInt(lpAmount),
+        });
+        ix.keys.push(...this.aumRemainingAccounts());
+        return { ix, withdrawalKeypair };
+    }
+    ixExecuteWithdrawal({ owner, withdrawalAccount, tokenAccountPairs, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, token2022Program = spl_token_1.TOKEN_2022_PROGRAM_ID, tokenLpEscrow = this.state.tokenLpEscrow, mintLp = this.state.mintLp, }) {
+        // Flatten token account pairs into remaining accounts: [src1, dst1, src2, dst2, ...]
+        const tokenAccountMetas = tokenAccountPairs.flatMap((pair) => [
+            { pubkey: pair.tokenSrc, isWritable: true, isSigner: false },
+            { pubkey: pair.tokenDst, isWritable: true, isSigner: false },
+        ]);
+        const tokenLpSrc = defaultTokenAccount(this.state.mintLp, owner, tokenProgram);
+        const ix = exponentVaults.createExecuteWithdrawalInstruction({
+            vault: this.selfAddress,
+            exponentPrices: this.pda.exponentPrices()[0],
+            owner,
+            withdrawalAccount,
+            tokenLpSrc,
+            tokenLpEscrow,
+            mintLp,
+            tokenProgram,
+            eventAuthority: this.eventAuthority,
+            program: this.programId,
+            token2022Program: token2022Program,
+        }, { tokenTransferAccountsUntil: tokenAccountPairs.length * 2 });
+        ix.keys.push(...tokenAccountMetas, ...this.aumRemainingAccounts());
+        return ix;
+    }
+    ixExecuteWithdrawalFromReserves({ owner, entryIdx, lpAmount, tokenSrc, tokenVaultSrc, tokenDst, tokenLpSrc, squadsProgram, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, token2022Program = spl_token_1.TOKEN_2022_PROGRAM_ID, tokenLpEscrow = this.state.tokenLpEscrow, mintLp = this.state.mintLp, }) {
+        const lpSrc = tokenLpSrc ?? defaultTokenAccount(this.state.mintLp, owner, tokenProgram);
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        const squadsSettings = this.state.squadsSettings;
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed: 2n, // Policy seed 2 is the vault-authorized transfer policy created at init
+        });
+        const ix = exponentVaults.createExecuteWithdrawalFromReservesInstruction({
+            owner,
+            vault: this.selfAddress,
+            exponentPrices: this.pda.exponentPrices()[0],
+            tokenLpSrc: lpSrc,
+            tokenLpEscrow,
+            tokenVaultSrc,
+            mintLp,
+            tokenSrc,
+            tokenDst,
+            tokenProgram,
+            token2022Program,
+            squadsVault: this.state.squadsVault,
+            squadsPolicy: squadsPolicy,
+            squadsProgram: squadsProgram,
+        }, { entryIdx, lpAmount: toBigInt(lpAmount) });
+        ix.keys.push(...this.aumRemainingAccounts());
+        return ix;
+    }
+    ixFillWithdrawal({ withdrawalAccount, fills, tokenAccountTriples, mintLp = this.state.mintLp, tokenLpEscrow = this.state.tokenLpEscrow, }) {
+        const ix = exponentVaults.createFillWithdrawalInstruction({
+            exponentVaultsProgram: this.programId,
+            squadsVault: this.state.squadsVault,
+            vault: this.selfAddress,
+            exponentPrices: this.pda.exponentPrices()[0],
+            withdrawalAccount,
+            mintLp,
+            tokenLpEscrow,
+            tokenProgramLp: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, {
+            fills: fills.map((f) => ({
+                tokenEntryIdx: f.tokenEntryIdx,
+                percentOfTotalLpBp: toBigInt(f.percentOfTotalLpBp),
+            })),
+        });
+        // Remaining accounts layout: [aum_accounts..., token_src_0, token_dst_0, token_program_0, ...]
+        const tokenTransferMetas = tokenAccountTriples.flatMap((triple) => [
+            { pubkey: triple.tokenSrc, isWritable: true, isSigner: false },
+            { pubkey: triple.tokenDst, isWritable: true, isSigner: false },
+            { pubkey: triple.tokenProgram, isWritable: false, isSigner: false },
+        ]);
+        ix.keys.push(...this.aumRemainingAccounts(), ...tokenTransferMetas);
+        return ix;
+    }
+    ixWrapperExecuteWithdrawal({ owner, withdrawalAccount, tokenAccountPairs, entryIdx, tokenSrc, tokenVaultSrc, tokenDst, squadsProgram, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, token2022Program = spl_token_1.TOKEN_2022_PROGRAM_ID, tokenLpEscrow = this.state.tokenLpEscrow, mintLp = this.state.mintLp, }) {
+        const tokenLpSrc = defaultTokenAccount(this.state.mintLp, owner, tokenProgram);
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        const [squadsPolicy] = squadsPda.policy({
+            settings: this.state.squadsSettings,
+            policySeed: 2n,
+        });
+        const tokenAccountMetas = tokenAccountPairs.flatMap((pair) => [
+            { pubkey: pair.tokenSrc, isWritable: true, isSigner: false },
+            { pubkey: pair.tokenDst, isWritable: true, isSigner: false },
+        ]);
+        const ix = exponentVaults.createWrapperExecuteWithdrawalInstruction({
+            vault: this.selfAddress,
+            exponentPrices: this.pda.exponentPrices()[0],
+            owner,
+            withdrawalAccount,
+            tokenLpSrc,
+            tokenLpEscrow,
+            mintLp,
+            tokenProgram,
+            token2022Program,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            tokenSrc,
+            tokenVaultSrc,
+            tokenDst,
+            squadsVault: this.state.squadsVault,
+            squadsPolicy,
+            squadsProgram,
+            eventAuthority: this.eventAuthority,
+            program: this.programId,
+        }, { tokenTransferAccountsUntil: tokenAccountPairs.length * 2, entryIdx });
+        ix.keys.push(...tokenAccountMetas, ...this.aumRemainingAccounts());
+        return ix;
+    }
+    ixCancelWithdrawal({ owner, withdrawalAccount, tokenLpDst, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, tokenLpEscrow = this.state.tokenLpEscrow, }) {
+        const lpDst = tokenLpDst ?? defaultTokenAccount(this.state.mintLp, owner, tokenProgram);
+        return exponentVaults.createCancelWithdrawalInstruction({
+            owner,
+            vault: this.selfAddress,
+            withdrawalAccount,
+            tokenLpEscrow,
+            tokenLpDst: lpDst,
+            tokenProgram,
+        });
+    }
+    // ixCollectManagementFee({
+    //   manager,
+    //   mintLp = this.state.mintLp,
+    //   feeTreasury = this.state.feeTreasury,
+    //   tokenProgram = TOKEN_PROGRAM_ID,
+    // }: CollectManagementFeeParams) {
+    //   return exponentVaults.createCollectManagementFeeInstruction({
+    //     manager,
+    //     vault: this.selfAddress,
+    //     mintLp,
+    //     feeTreasury,
+    //     tokenProgram,
+    //   })
+    // }
+    /**
+     * Create instruction to call wrapper_manage_vault_settings.
+     */
+    ixWrapperManageVaultSettings({ manager, actions, remainingAccounts = [], exponentPrices = this.pda.exponentPrices()[0], systemProgram = web3_js_1.SystemProgram.programId, }) {
+        const ix = exponentVaults.createWrapperManageVaultSettingsInstruction({
+            manager,
+            vault: this.selfAddress,
+            exponentPrices,
+            systemProgram,
+        }, { actions });
+        ix.keys.push(...remainingAccounts);
+        return ix;
+    }
+    /**
+     * Create instruction to call wrapper_manager_update_position.
+     */
+    ixWrapperManagerUpdatePosition({ manager, update, remainingAccounts = [], exponentPrices = this.pda.exponentPrices()[0], systemProgram = web3_js_1.SystemProgram.programId, }) {
+        const ix = exponentVaults.createWrapperManagerUpdatePositionInstruction({
+            manager,
+            vault: this.selfAddress,
+            exponentPrices,
+            systemProgram,
+        }, { update });
+        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
+    // ==========================================================================
+    /**
+     * Create instruction to add a policy to this vault.
+     * Direct policy management requires an empty vault; live vaults must use proposals.
+     */
+    ixAddPolicy({ payer, policyConfig, squadsProgram, nextPolicySeed, nextTransactionIndex }) {
+        const squadsSettings = this.state.squadsSettings;
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        // Derive Squads PDAs
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed: nextPolicySeed,
+        });
+        return exponentVaults.createAddPolicyInstruction({
+            payer,
+            vault: this.selfAddress,
+            squadsSettings,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicy,
+            squadsProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { policyConfig: this.toCodamaPolicyConfig(policyConfig) });
+    }
+    /**
+     * Create instruction to call wrapper_add_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperAddPolicy({ payer, policyConfig, squadsProgram, nextPolicySeed, nextTransactionIndex, }) {
+        const squadsSettings = this.state.squadsSettings;
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed: nextPolicySeed,
+        });
+        return exponentVaults.createWrapperAddPolicyInstruction({
+            payer,
+            vault: this.selfAddress,
+            squadsSettings,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicy,
+            squadsProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { policyConfig: this.toCodamaPolicyConfig(policyConfig) });
+    }
+    /**
+     * Create instruction to remove a policy from this vault.
+     * Direct policy management requires an empty vault; live vaults must use proposals.
+     */
+    ixRemovePolicy({ payer, manager, policySeed, squadsProgram, nextTransactionIndex }) {
+        const squadsSettings = this.state.squadsSettings;
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        // Derive Squads PDAs
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed,
+        });
+        return exponentVaults.createRemovePolicyInstruction({
+            payer,
+            vault: this.selfAddress,
+            manager,
+            squadsSettings,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicy,
+            squadsProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        });
+    }
+    /**
+     * Create instruction to call wrapper_remove_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperRemovePolicy({ payer, manager, policySeed, squadsProgram, nextTransactionIndex, }) {
+        const squadsSettings = this.state.squadsSettings;
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed,
+        });
+        return exponentVaults.createWrapperRemovePolicyInstruction({
+            payer,
+            vault: this.selfAddress,
+            manager,
+            squadsSettings,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicy,
+            squadsProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        });
+    }
+    /**
+     * Create instruction to call wrapper_update_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperUpdatePolicy({ payer, manager, policyConfig, policySeed, squadsProgram, nextTransactionIndex, }) {
+        const squadsSettings = this.state.squadsSettings;
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(squadsProgram);
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: squadsSettings,
+            policySeed,
+        });
+        return exponentVaults.createWrapperUpdatePolicyInstruction({
+            payer,
+            vault: this.selfAddress,
+            manager,
+            squadsSettings,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicy,
+            squadsProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { policyConfig: this.toCodamaPolicyConfig(policyConfig) });
+    }
+    // ==========================================================================
+    // Price Management Methods
+    // ==========================================================================
+    /**
+     * Derive the ExponentPrices PDA for this vault.
+     */
+    deriveExponentPricesAddress() {
+        const vaultsPda = new exponent_vaults_pda_1.ExponentVaultsPDA(this.programId);
+        return vaultsPda.exponentPrices();
+    }
+    // ==========================================================================
+    // Static Factory Methods
+    // ==========================================================================
+    /**
+     * Create instruction to initialize the global ExponentPrices account.
+     * The account is a singleton PDA derived from ["exponent_prices"].
+     */
+    static ixInitializePrices({ manager, programId: programIdOverride }) {
+        const programId = programIdOverride ?? new web3_js_1.PublicKey(exponent_vaults_idl_1.PROGRAM_ID);
+        const [exponentPrices] = new exponent_vaults_pda_1.ExponentVaultsPDA(programId).exponentPrices();
+        return exponentVaults.createInitializePricesInstruction({
+            manager,
+            exponentPrices,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, programId);
+    }
+    /**
+     * Create instruction to manage price entries (add/remove/update) in the ExponentPrices account.
+     * Uses realloc to resize the account as prices are added or removed.
+     */
+    static ixManagePrices({ manager, actions, programId: programIdOverride }) {
+        const programId = programIdOverride ?? new web3_js_1.PublicKey(exponent_vaults_idl_1.PROGRAM_ID);
+        const [exponentPrices] = new exponent_vaults_pda_1.ExponentVaultsPDA(programId).exponentPrices();
+        const remainingAccounts = [];
+        const codamaActions = actions.map((action) => convertUpdatePriceAction(action, programId, exponentPrices, remainingAccounts));
+        const ix = exponentVaults.createManagePricesInstruction({ manager, exponentPrices, systemProgram: web3_js_1.SystemProgram.programId }, { actions: codamaActions }, programId);
+        ix.keys.push(...remainingAccounts);
+        return ix;
+    }
+    /**
+     * Create instruction to initialize a new vault.
+     * This is a static method since the vault doesn't exist yet.
+     */
+    static ixInitializeVault(params, env) {
+        const programId = env.exponentVaultsProgramId ?? new web3_js_1.PublicKey(exponent_vaults_idl_1.PROGRAM_ID);
+        const vaultsPda = new exponent_vaults_pda_1.ExponentVaultsPDA(programId);
+        const squadsPda = new exponent_vaults_pda_1.SquadsPDA(params.squadsProgram);
+        const tokenProgram = params.tokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID;
+        // Derive vault PDA
+        const [vault] = vaultsPda.vault({ seedId: params.seedId });
+        const [mintLp] = vaultsPda.mintLp({ vault });
+        const [tokenLpEscrow] = vaultsPda.tokenLpEscrow({ vault });
+        // Derive LP destination (ATA for payer)
+        const lpDst = (0, spl_token_1.getAssociatedTokenAddressSync)(mintLp, params.payer, false, tokenProgram);
+        // Squads account is created via CPI during initialize_vault
+        // The on-chain program creates the Squads smart account first, so these start at 1
+        const nextTransactionIndex = BigInt(1);
+        const nextPolicySeed = BigInt(1);
+        const nextTransactionTransferIndex = BigInt(2);
+        const nextPolicyTransferSeed = BigInt(2);
+        // Derive Squads PDAs for the policy that gets created after the Squads account
+        // These all use squadsSettings (the Settings account) as the base key
+        const [squadsSettingsTransaction] = squadsPda.transaction({
+            settings: params.squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsProposal] = squadsPda.proposal({
+            settings: params.squadsSettings,
+            transactionIndex: nextTransactionIndex,
+        });
+        const [squadsPolicy] = squadsPda.policy({
+            settings: params.squadsSettings,
+            policySeed: nextPolicySeed,
+        });
+        // Derive Squads PDAs for the transfer accounts
+        const [squadsPolicyTransfer] = squadsPda.policy({
+            settings: params.squadsSettings,
+            policySeed: nextPolicyTransferSeed,
+        });
+        const [squadsSettingsTransactionTransfer] = squadsPda.transaction({
+            settings: params.squadsSettings,
+            transactionIndex: nextTransactionTransferIndex,
+        });
+        const [squadsProposalTransfer] = squadsPda.proposal({
+            settings: params.squadsSettings,
+            transactionIndex: nextTransactionTransferIndex,
+        });
+        // Convert token entries to Codama format
+        const codamaTokenEntries = params.tokenEntries.map((entry) => ({
+            mint: entry.mint,
+            priceId: toCodamaPriceId(entry.priceId),
+            tokenSquadsAccount: entry.tokenSquadsAccount,
+            tokenAccountVault: entry.tokenAccountVault,
+            forceDeallocatePolicyIds: (entry.forceDeallocatePolicyIds ?? []).map((id) => toBigInt(id)),
+        }));
+        // Convert seedId to Uint8Array
+        const seedIdArray = new Uint8Array(params.seedId);
+        if (seedIdArray.length !== 8) {
+            throw new Error(`seedId must contain 8 bytes, received ${seedIdArray.length}`);
+        }
+        // Convert roles
+        const codamaRoles = {
+            manager: params.roles.manager,
+            curator: params.roles.curator,
+            allocator: params.roles.allocator,
+            sentinel: params.roles.sentinel,
+        };
+        // Convert proposal vote config if provided
+        const codamaProposalVoteConfig = params.proposalVoteConfig
+            ? {
+                minVotingPeriodSeconds: params.proposalVoteConfig.minVotingPeriodSeconds,
+                maxVotingPeriodSeconds: params.proposalVoteConfig.maxVotingPeriodSeconds,
+                defaultVotingPeriodSeconds: params.proposalVoteConfig.defaultVotingPeriodSeconds,
+                defaultTimelockSeconds: params.proposalVoteConfig.defaultTimelockSeconds,
+                rejectionThresholdBps: toBigInt(params.proposalVoteConfig.rejectionThresholdBps),
+                nextProposalId: toBigInt(params.proposalVoteConfig.nextProposalId),
+                votingEnabled: params.proposalVoteConfig.votingEnabled,
+                liveProposalsCount: params.proposalVoteConfig.liveProposalsCount,
+                maxConcurrentLiveProposals: params.proposalVoteConfig.maxConcurrentLiveProposals,
+                reserved: new Uint8Array(params.proposalVoteConfig.reserved),
+            }
+            : null;
+        const [exponentPrices] = new exponent_vaults_pda_1.ExponentVaultsPDA(programId).exponentPrices();
+        return exponentVaults.createInitializeVaultInstruction({
+            payer: params.payer,
+            vault,
+            exponentPrices,
+            mint: params.mint,
+            mintLp,
+            tokenLpEscrow,
+            feeTreasury: params.feeTreasury,
+            lpDst,
+            tokenProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            addressLookupTable: params.addressLookupTable,
+            squadsProgram: params.squadsProgram,
+            squadsProgramConfig: params.squadsProgramConfig,
+            squadsTreasury: params.squadsTreasury,
+            squadsSettings: params.squadsSettings,
+            squadsVault: params.squadsVault,
+            squadsPolicy,
+            squadsSettingsTransaction,
+            squadsProposal,
+            squadsPolicyTransfer,
+            squadsSettingsTransactionTransfer,
+            squadsProposalTransfer,
+        }, {
+            manager: params.manager,
+            feeTreasuryLpBps: params.normalWithdrawalFeeBps,
+            managementFeeBps: toBigInt(params.managementFeeBps),
+            reservesShareBp: params.reservesShareBp,
+            fastWithdrawalCutBp: params.fastWithdrawalCutBp ?? 0,
+            tokenEntries: codamaTokenEntries,
+            maxLpSupply: toBigInt(params.maxLpSupply),
+            seedId: seedIdArray,
+            initialLpAmount: toBigInt(params.initialLpAmount),
+            lpDecimals: params.lpDecimals,
+            roles: codamaRoles,
+            proposalVoteConfig: codamaProposalVoteConfig,
+        });
+    }
+    async fetchTotalAumInfo(pricesAccount, jitoBundleRpc) {
+        const aum = await this.getTotalAumViaJitoBundle(pricesAccount, jitoBundleRpc);
+        const { supply: lpSupply, decimals: lpDecimals } = await (0, spl_token_1.getMint)(this.connection, this.state.mintLp);
+        const underlyingDecimals = await getMintDecimals(this.connection, this.state.underlyingMint);
+        if (lpSupply === 0n) {
+            return {
+                aum,
+                aumHuman: 0,
+                lpRate: 0,
+                lpSupply,
+                lpDecimals,
+                underlyingDecimals,
+            };
+        }
+        const lpHuman = Number(lpSupply.toString()) / 10 ** lpDecimals;
+        const aumHuman = Number(aum.toString()) / 10 ** underlyingDecimals;
+        const lpRate = aumHuman / lpHuman;
+        return {
+            aum,
+            aumHuman,
+            lpRate,
+            lpSupply,
+            lpDecimals,
+            underlyingDecimals,
+        };
+    }
+    /**
+     * LP token price: AUM / LP supply.
+     * Returns 0 when LP supply is zero.
+     */
+    async getLpPrice() {
+        const aum = this.getTotalAum();
+        const lpSupply = await this.fetchLpTokenSupply();
+        const quoteDecimals = await getMintDecimals(this.connection, this.state.underlyingMint);
+        const lpSupplyNum = parseInt(lpSupply.toString());
+        if (lpSupplyNum === 0)
+            return 0;
+        const aumHuman = parseInt(aum.toString()) / 10 ** quoteDecimals;
+        const lpMintInfo = await (0, spl_token_1.getMint)(this.connection, this.state.mintLp);
+        return aumHuman / (lpSupplyNum / 10 ** lpMintInfo.decimals);
+    }
+    /**
+     * Total AUM: on-chain tracked base value + value held in strategy positions.
+     */
+    getTotalAum() {
+        return this.aumCalculator.getTotalAum();
+    }
+    /**
+     * Calculates total AUM by simulating a bundle that updates prices and deposits liquidity.
+     * Requires an RPC endpoint that supports the `simulateBundle` method (e.g., Jito, Helius).
+     */
+    async getTotalAumViaJitoBundle(pricesAccount, jitoBundleRpc) {
+        try {
+            const rpcUrl = jitoBundleRpc ?? this.connection.rpcEndpoint;
+            const depositor = this.state.roles.manager[0];
+            if (!depositor) {
+                throw new Error("Vault manager not found");
+            }
+            const depositMint = this.state.tokenEntries[0]?.mint;
+            if (!depositMint) {
+                throw new Error("Deposit token not found");
+            }
+            const [updatePriceIxs, depositIxs] = await Promise.all([
+                this.ixsUpdateStrategyVaultPrices(pricesAccount),
+                this.ixsDepositLiquidity({
+                    depositor,
+                    mint: depositMint,
+                    tokenAmountIn: 1,
+                    minLpOut: 0,
+                }),
+            ]);
+            // Use a dummy blockhash - Jito will replace it with replaceRecentBlockhash
+            const blockhash = "11111111111111111111111111111111";
+            const encodedTransactions = [];
+            if (updatePriceIxs.length > 0) {
+                const priceMsg = new web3_js_1.TransactionMessage({
+                    payerKey: depositor,
+                    recentBlockhash: blockhash,
+                    instructions: updatePriceIxs,
+                }).compileToV0Message();
+                encodedTransactions.push(Buffer.from(new web3_js_1.VersionedTransaction(priceMsg).serialize()).toString("base64"));
+            }
+            const depositMsg = new web3_js_1.TransactionMessage({
+                payerKey: depositor,
+                recentBlockhash: blockhash,
+                instructions: depositIxs,
+            }).compileToV0Message();
+            encodedTransactions.push(Buffer.from(new web3_js_1.VersionedTransaction(depositMsg).serialize()).toString("base64"));
+            const rpcResponse = await fetch(rpcUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "simulateBundle",
+                    params: [
+                        { encodedTransactions },
+                        {
+                            preExecutionAccountsConfigs: [
+                                null,
+                                null,
+                                // {
+                                //   addresses: [this.state.selfAddress.toBase58()],
+                                //   encoding: "base64",
+                                // },
+                            ],
+                            postExecutionAccountsConfigs: [
+                                null,
+                                {
+                                    addresses: [this.state.selfAddress.toBase58()],
+                                    encoding: "base64",
+                                },
+                            ],
+                            transactionEncoding: "base64",
+                            skipSigVerify: true,
+                            replaceRecentBlockhash: true,
+                            simulationBank: { commitment: { commitment: "processed" } },
+                        },
+                    ],
+                }),
+                cache: "no-store",
+            });
+            const responseBody = (await rpcResponse.json().catch(() => null));
+            const txnResults = responseBody?.result?.value?.transactionResults || [];
+            if (!rpcResponse.ok || responseBody?.error) {
+                throw new Error("Jito bundle simulation failed");
+            }
+            const depositFailed = !!txnResults[1].err;
+            if (depositFailed) {
+                throw new Error("Jito bundle simulation failed");
+            }
+            const postVaultAccountData = txnResults[1]?.postExecutionAccounts?.[0]?.data?.[0];
+            if (!postVaultAccountData) {
+                throw new Error("Jito bundle simulation failed");
+            }
+            const vaultStateAfterSimulations = (0, fetcher_1.deserializeExponentStrategyVaultFetcherShape)(Buffer.from(postVaultAccountData, "base64"));
+            const aum = vaultStateAfterSimulations.financials.aumInBase + vaultStateAfterSimulations.financials.aumInBaseInPositions;
+            return aum;
+        }
+        catch {
+            console.warn("Unable to calculate AUM via simulation. Using AUM from vault.state");
+            return this.getTotalAum();
+        }
+    }
+    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 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,
+            });
+        });
+    }
+    // ==========================================================================
+    // Helper Methods — Codama type conversions
+    // ==========================================================================
+    /**
+     * 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.
+     */
+    toCodamaPolicyConfig(config) {
+        return {
+            payload: this.toCodamaPolicyPayload(config.policyType),
+            threshold: config.threshold,
+            timeLock: config.timeLock,
+            startTimestamp: config.startTimestamp,
+            expiration: config.expiration ? this.toCodamaPolicyExpiration(config.expiration) : null,
+        };
+    }
+    toCodamaPolicyPayload(policyType) {
+        if ("programInteraction" in policyType) {
+            const pi = policyType.programInteraction;
+            // Post-hook for interaction validation (matches initialize_vault.rs).
+            // num_extra_accounts: 7 (vault, exponent_prices, mint_lp, payer,
+            // system_program, instructions_sysvar, squads_policy).
+            // program_id is separate, so total = 8 accounts.
+            const validateInteractionPostHook = {
+                numExtraAccounts: 7,
+                accountConstraints: [],
+                instructionData: new Uint8Array([21]), // validate_interaction_hook discriminator
+                programId: this.programId,
+                passInnerInstructions: true,
+            };
+            const payload = {
+                accountIndex: pi.accountIndex,
+                instructionsConstraints: pi.instructionsConstraints.map((ic) => ({
+                    programId: ic.programId,
+                    accountConstraints: ic.accountConstraints.map((ac) => ({
+                        accountIndex: ac.accountIndex,
+                        accountConstraint: ac.accountDataConstraints && ac.accountDataConstraints.length > 0
+                            ? {
+                                __kind: "AccountData",
+                                fields: [ac.accountDataConstraints.map((dc) => this.toCodamaDataConstraint(dc))],
+                            }
+                            : { __kind: "Pubkey", fields: [ac.accountKeys ?? []] },
+                        owner: ac.owner ?? null,
+                    })),
+                    dataConstraints: ic.dataConstraints.map((dc) => this.toCodamaDataConstraint(dc)),
+                })),
+                preHook: null,
+                postHook: validateInteractionPostHook,
+                spendingLimits: pi.spendingLimits.map((sl) => ({
+                    mint: sl.mint,
+                    timeConstraints: {
+                        start: sl.timeConstraints.start,
+                        expiration: sl.timeConstraints.expiration,
+                        period: this.toCodamaPeriod(sl.timeConstraints.period),
+                    },
+                    quantityConstraints: { maxPerPeriod: sl.quantityConstraints.maxPerPeriod },
+                })),
+            };
+            return { __kind: "ProgramInteraction", fields: [payload] };
+        }
+        if ("internalFundTransfer" in policyType) {
+            const ift = policyType.internalFundTransfer;
+            const payload = {
+                sourceAccountIndices: new Uint8Array(ift.sourceAccountMask),
+                destinationAccountIndices: new Uint8Array(ift.destinationAccountMask),
+                allowedMints: ift.allowedMints,
+            };
+            return { __kind: "InternalFundTransfer", fields: [payload] };
+        }
+        if ("settingsChange" in policyType) {
+            const sc = policyType.settingsChange;
+            const payload = {
+                actions: sc.allowedActions.map((a) => this.toCodamaAllowedSettingsChange(a)),
+            };
+            return { __kind: "SettingsChange", fields: [payload] };
+        }
+        if ("spendingLimit" in policyType) {
+            const spl = policyType.spendingLimit;
+            const payload = {
+                mint: spl.spendingLimit.mint,
+                sourceAccountIndex: spl.sourceAccountIndex,
+                timeConstraints: {
+                    start: spl.spendingLimit.timeConstraints.start,
+                    expiration: spl.spendingLimit.timeConstraints.expiration,
+                    period: this.toCodamaPeriod(spl.spendingLimit.timeConstraints.period),
+                    accumulateUnused: false,
+                },
+                quantityConstraints: {
+                    maxPerPeriod: spl.spendingLimit.quantityConstraints.maxPerPeriod,
+                    maxPerUse: 0n,
+                    enforceExactQuantity: false,
+                },
+                usageState: null,
+                destinations: spl.destinations,
+            };
+            return { __kind: "SpendingLimit", fields: [payload] };
+        }
+        throw new Error("Unsupported policy type for Codama migration");
+    }
+    toCodamaDataConstraint(constraint) {
+        return {
+            dataOffset: constraint.dataOffset,
+            dataValue: this.toCodamaDataValue(constraint.dataValue),
+            operator: this.toCodamaDataOperator(constraint.operator),
+        };
+    }
+    toCodamaDataValue(value) {
+        if ("u8" in value)
+            return { __kind: "U8", fields: [value.u8] };
+        if ("u16Le" in value)
+            return { __kind: "U16Le", fields: [value.u16Le] };
+        if ("u32Le" in value)
+            return { __kind: "U32Le", fields: [value.u32Le] };
+        if ("u64Le" in value)
+            return { __kind: "U64Le", fields: [value.u64Le] };
+        if ("u128Le" in value)
+            return { __kind: "U128Le", fields: [value.u128Le] };
+        if ("u8Slice" in value)
+            return { __kind: "U8Slice", fields: [new Uint8Array(value.u8Slice)] };
+        throw new Error("Unknown data value type");
+    }
+    toCodamaDataOperator(op) {
+        const map = {
+            Equals: exponentVaults.DataOperator.Equals,
+            NotEquals: exponentVaults.DataOperator.NotEquals,
+            GreaterThan: exponentVaults.DataOperator.GreaterThan,
+            GreaterThanOrEqualTo: exponentVaults.DataOperator.GreaterThanOrEqualTo,
+            LessThan: exponentVaults.DataOperator.LessThan,
+            LessThanOrEqualTo: exponentVaults.DataOperator.LessThanOrEqualTo,
+        };
+        return map[op];
+    }
+    toCodamaPeriod(period) {
+        const map = {
+            OneTime: { __kind: "OneTime" },
+            Daily: { __kind: "Daily" },
+            Weekly: { __kind: "Weekly" },
+            Monthly: { __kind: "Monthly" },
+        };
+        const result = map[period];
+        if (!result)
+            throw new Error(`Unsupported period: ${period}`);
+        return result;
+    }
+    toCodamaPolicyExpiration(expiration) {
+        if ("timestamp" in expiration)
+            return { __kind: "Timestamp", fields: [expiration.timestamp] };
+        if ("settingsState" in expiration)
+            return { __kind: "SettingsState" };
+        throw new Error("Unknown expiration type");
+    }
+    toCodamaAllowedSettingsChange(change) {
+        switch (change) {
+            case "AddSigner":
+                return { __kind: "AddSigner", newSigner: null, newSignerPermissions: null };
+            case "RemoveSigner":
+                return { __kind: "RemoveSigner", oldSigner: null };
+            case "ChangeThreshold":
+                return { __kind: "ChangeThreshold" };
+            case "ChangeTimeLock":
+                return { __kind: "ChangeTimeLock", newTimeLock: null };
+            default:
+                throw new Error(`Unsupported settings change: ${change}`);
+        }
+    }
+}
+exports.ExponentVault = ExponentVault;
+//# sourceMappingURL=vault.js.map