@reflectmoney/junior 1.0.0

package/dist/classes/JuniorTranche.js

@@ -0,0 +1,709 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JuniorTranche = void 0;
+const token_1 = require("@solana-program/token");
+const kit_1 = require("@solana/kit");
+const generated_1 = require("../generated");
+const PdaClient_1 = require("./PdaClient");
+class JuniorTranche {
+    connection;
+    settings;
+    liquidityPools;
+    assets;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    async load() {
+        this.settings = await this.getSettingsData();
+        this.liquidityPools = await this.getLiquidityPools();
+        this.assets = await this.getAssets();
+    }
+    async getSettingsData() {
+        const [settingsAddress] = await PdaClient_1.PdaClient.deriveSettings();
+        const account = await (0, generated_1.fetchSettings)(this.connection, settingsAddress);
+        return account.data;
+    }
+    async getLiquidityPools() {
+        const decoder = (0, generated_1.getLiquidityPoolDecoder)();
+        const programAccounts = await this.connection
+            .getProgramAccounts(generated_1.RLP_PROGRAM_ADDRESS, {
+            encoding: "base64",
+            withContext: false,
+            filters: [
+                {
+                    memcmp: {
+                        encoding: "base64",
+                        offset: BigInt(0),
+                        bytes: Buffer.from(generated_1.LIQUIDITY_POOL_DISCRIMINATOR).toString("base64"),
+                    },
+                },
+            ],
+        })
+            .send();
+        return programAccounts.map((account) => {
+            const [b64] = account.account.data;
+            const bytes = new Uint8Array(Buffer.from(b64, "base64"));
+            return {
+                address: account.pubkey,
+                data: decoder.decode(bytes),
+            };
+        });
+    }
+    async getLiquidityPoolData(liquidityPoolId) {
+        const [liquidityPoolAddress] = await PdaClient_1.PdaClient.deriveLiquidityPool(liquidityPoolId);
+        const account = await (0, generated_1.fetchLiquidityPool)(this.connection, liquidityPoolAddress);
+        return account.data;
+    }
+    async getAssets() {
+        if (this.assets?.length > 0) {
+            return this.assets;
+        }
+        const encoder = (0, generated_1.getAssetEncoder)();
+        const decoder = (0, generated_1.getAssetDecoder)();
+        const programAccounts = await this.connection
+            .getProgramAccounts(generated_1.RLP_PROGRAM_ADDRESS, {
+            encoding: "base64",
+            withContext: false,
+            filters: [
+                { dataSize: BigInt(encoder.fixedSize) },
+            ],
+        })
+            .send();
+        const preSorted = programAccounts
+            .map((account) => {
+            const [b64] = account.account.data;
+            const bytes = new Uint8Array(Buffer.from(b64, "base64"));
+            return {
+                address: account.pubkey,
+                data: decoder.decode(bytes),
+            };
+        });
+        const result = preSorted.sort((a, b) => a.data.index - b.data.index);
+        this.assets = result;
+        return result;
+    }
+    async getCooldowns() {
+        const encoder = (0, generated_1.getCooldownEncoder)();
+        const decoder = (0, generated_1.getCooldownDecoder)();
+        const programAccounts = await this.connection
+            .getProgramAccounts(generated_1.RLP_PROGRAM_ADDRESS, {
+            encoding: "base64",
+            withContext: false,
+            filters: [
+                { dataSize: BigInt(encoder.fixedSize) },
+            ],
+        })
+            .send();
+        return programAccounts.map((account) => {
+            const [b64] = account.account.data;
+            const bytes = new Uint8Array(Buffer.from(b64, "base64"));
+            return {
+                address: account.pubkey,
+                data: decoder.decode(bytes),
+            };
+        });
+    }
+    async getCooldownsByUser(user) {
+        const allCooldowns = await this.getCooldowns();
+        return allCooldowns.filter((c) => c.data.authority === user);
+    }
+    async getUserPermissions() {
+        const decoder = (0, generated_1.getUserPermissionsDecoder)();
+        const programAccounts = await this.connection
+            .getProgramAccounts(generated_1.RLP_PROGRAM_ADDRESS, {
+            encoding: "base64",
+            withContext: false,
+            filters: [
+                {
+                    memcmp: {
+                        encoding: "base64",
+                        offset: BigInt(0),
+                        bytes: Buffer.from(generated_1.USER_PERMISSIONS_DISCRIMINATOR).toString("base64"),
+                    },
+                },
+            ],
+        })
+            .send();
+        return programAccounts.map((account) => {
+            const [b64] = account.account.data;
+            const bytes = new Uint8Array(Buffer.from(b64, "base64"));
+            return {
+                address: account.pubkey,
+                data: decoder.decode(bytes),
+            };
+        });
+    }
+    async getUserPermissionsFromAddress(address) {
+        const allPermissions = await this.getUserPermissions();
+        return allPermissions.filter((p) => p.data.authority === address);
+    }
+    async initializeRlp(signer, swapFeeBps) {
+        return (0, generated_1.getInitializeRlpInstructionAsync)({
+            signer,
+            swapFeeBps,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async initializeLiquidityPool(signer, args) {
+        const settings = await this.getSettingsData();
+        const [liquidityPoolAddress] = await PdaClient_1.PdaClient.deriveLiquidityPool(settings.liquidityPools);
+        return (0, generated_1.getInitializeLpInstructionAsync)({
+            signer,
+            liquidityPool: liquidityPoolAddress,
+            lpTokenMint: args.lpTokenMint,
+            cooldownDuration: args.cooldownDuration,
+            depositCap: args.depositCap,
+            assets: new Uint8Array(args.assets),
+            protectedVault: (args.protectedVault ?? null),
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    /**
+     * Create the canonical pool reserve ATA for a single asset. Required after
+     * `initialize_lp` before any deposit/withdraw/swap against that asset can
+     * succeed (audit-E02). Idempotent: safe to call again on an already-
+     * initialized reserve.
+     */
+    async initializePoolReserve(signer, liquidityPoolId, assetMint) {
+        const [liquidityPoolAddress] = await PdaClient_1.PdaClient.deriveLiquidityPool(liquidityPoolId);
+        const [assetPda] = await PdaClient_1.PdaClient.deriveAsset(assetMint);
+        return (0, generated_1.getInitializePoolReserveInstructionAsync)({
+            signer,
+            liquidityPool: liquidityPoolAddress,
+            asset: assetPda,
+            assetMint,
+            liquidityPoolId,
+        });
+    }
+    /**
+     * Admin recovery for a permanently-frozen pool asset (audit-M02). Drops the
+     * asset from the pool's reserve list. Requires the asset's pool reserve ATA
+     * to actually be in the SPL `Frozen` state.
+     */
+    async forceRemoveAsset(signer, liquidityPoolId, assetMint) {
+        const [liquidityPoolAddress] = await PdaClient_1.PdaClient.deriveLiquidityPool(liquidityPoolId);
+        const [assetPda] = await PdaClient_1.PdaClient.deriveAsset(assetMint);
+        const [poolTokenAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: assetMint,
+            owner: liquidityPoolAddress,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        return (0, generated_1.getForceRemoveAssetInstructionAsync)({
+            signer,
+            liquidityPool: liquidityPoolAddress,
+            asset: assetPda,
+            assetMint,
+            poolTokenAccount,
+            liquidityPoolId,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async addAsset(signer, assetMint, oracle, accessLevel) {
+        return (0, generated_1.getAddAssetInstructionAsync)({
+            signer,
+            assetMint,
+            oracle,
+            accessLevel,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async updateOracle(signer, assetMint, oracle) {
+        const assets = await this.getAssets();
+        const assetEntry = assets.find((a) => a.data.mint === assetMint);
+        if (!assetEntry)
+            throw new Error(`Asset not found for mint ${assetMint}`);
+        return (0, generated_1.getUpdateOracleInstructionAsync)({
+            signer,
+            asset: assetEntry.address,
+            oracle,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    /**
+     * NAV-based junior-tranche slash (audit-M06 redesign). Pulls from this
+     * pool's reserve of the proxy's `stablecoinMint` directly into the proxy's
+     * vault, capped on-chain at the current mark-to-market loss
+     * `principal + commission - vault_value`.
+     *
+     * The pool must have been initialized with `protectedVault` pinned to the
+     * supplied `proxyState`. The proxy's stablecoin_mint must equal the
+     * `stablecoinMint` arg, and the pool must whitelist that mint as one of
+     * its assets.
+     *
+     * @param signer            Caller (must hold the Slash action role).
+     * @param liquidityPoolId   The pool index.
+     * @param stablecoinMint    The proxy's underlying stablecoin (USDC+).
+     * @param proxyState        The senior tranche's ProxyState account.
+     * @param amount            Requested amount in raw stablecoin_mint units.
+     *                          Capped at the current gap; pass any positive
+     *                          value up to that cap.
+     */
+    async slash(signer, liquidityPoolId, stablecoinMint, proxyState, amount) {
+        const [liquidityPoolAddress] = await PdaClient_1.PdaClient.deriveLiquidityPool(liquidityPoolId);
+        const assets = await this.getAssets();
+        const assetEntry = assets.find((a) => a.data.mint === stablecoinMint);
+        if (!assetEntry)
+            throw new Error(`Asset not found for stablecoin mint ${stablecoinMint}`);
+        const oracleAddress = assetEntry.data.oracle.fields[0];
+        const [liquidityPoolTokenAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: stablecoinMint,
+            owner: liquidityPoolAddress,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const [protectedVaultTokenAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: stablecoinMint,
+            owner: proxyState,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        return (0, generated_1.getSlashInstructionAsync)({
+            signer,
+            liquidityPool: liquidityPoolAddress,
+            asset: assetEntry.address,
+            stablecoinMint,
+            liquidityPoolTokenAccount,
+            proxyState,
+            protectedVaultTokenAccount,
+            oracle: oracleAddress,
+            liquidityPoolId,
+            amount,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    /**
+     * Inject pre-fetched state (useful for testing without an RPC connection).
+     */
+    loadFromCache(settings, liquidityPools, assets) {
+        this.settings = settings;
+        this.liquidityPools = liquidityPools;
+        this.assets = assets;
+    }
+    /**
+     * Return the assets that belong to a specific liquidity pool,
+     * ordered by the pool's `assets` array.
+     */
+    async getPoolAssets(liquidityPoolId) {
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        const allAssets = await this.getAssets();
+        const poolAssetIndices = Array.from(lpEntry.data.assets).slice(0, lpEntry.data.assetCount);
+        return poolAssetIndices.map((assetIndex) => {
+            const asset = allAssets.find((a) => a.data.index === assetIndex);
+            if (!asset)
+                throw new Error(`Asset with index ${assetIndex} not found for pool ${liquidityPoolId}`);
+            return asset;
+        });
+    }
+    /**
+     * Build the remaining accounts needed by calculate_total_pool_value().
+     * Per asset (in pool asset order): [pool_ata, asset_pda, oracle, mint]
+     */
+    async buildPoolValueRemainingAccounts(liquidityPoolAddress, liquidityPoolId) {
+        const assets = await this.getPoolAssets(liquidityPoolId);
+        const remaining = [];
+        for (const asset of assets) {
+            const [poolAta] = await (0, token_1.findAssociatedTokenPda)({
+                mint: asset.data.mint,
+                owner: liquidityPoolAddress,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            });
+            const oracleAddress = asset.data.oracle.fields[0];
+            remaining.push({ address: poolAta, role: kit_1.AccountRole.READONLY }, { address: asset.address, role: kit_1.AccountRole.READONLY }, { address: oracleAddress, role: kit_1.AccountRole.READONLY }, { address: asset.data.mint, role: kit_1.AccountRole.READONLY });
+        }
+        return remaining;
+    }
+    /**
+     * Build the remaining accounts needed by withdraw's load_assets,
+     * load_reserves, and load_user_token_accounts.
+     *
+     * Layout (must match on-chain expectations):
+     *   - First N: asset PDAs (positional, for load_assets)
+     *   - Then N: pool reserve ATAs (searched by load_reserves)
+     *   - Then N: user token ATAs (searched by load_user_token_accounts)
+     */
+    async buildWithdrawRemainingAccounts(signer, liquidityPoolAddress, liquidityPoolId) {
+        const assets = await this.getPoolAssets(liquidityPoolId);
+        const assetPdas = [];
+        const reserves = [];
+        const userAtas = [];
+        for (const asset of assets) {
+            assetPdas.push({ address: asset.address, role: kit_1.AccountRole.READONLY });
+            const [poolReserve] = await (0, token_1.findAssociatedTokenPda)({
+                mint: asset.data.mint,
+                owner: liquidityPoolAddress,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            });
+            reserves.push({ address: poolReserve, role: kit_1.AccountRole.WRITABLE });
+            const [userAta] = await (0, token_1.findAssociatedTokenPda)({
+                mint: asset.data.mint,
+                owner: signer.address,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            });
+            userAtas.push({ address: userAta, role: kit_1.AccountRole.WRITABLE });
+        }
+        return [...assetPdas, ...reserves, ...userAtas];
+    }
+    /**
+     * Append remaining account metas to a frozen instruction object,
+     * returning a new instruction with the extra accounts.
+     */
+    appendRemainingAccounts(ix, remaining) {
+        const extraMetas = remaining.map((r) => Object.freeze({ address: r.address, role: r.role }));
+        return Object.freeze({
+            ...ix,
+            accounts: [...ix.accounts, ...extraMetas],
+        });
+    }
+    async deposit(signer, amount, mint, liquidityPoolId, minLpTokens) {
+        const assets = await this.getAssets();
+        const assetEntry = assets.find((a) => a.data.mint === mint);
+        if (!assetEntry)
+            throw new Error(`Asset not found for mint ${mint}`);
+        const oracleAddress = assetEntry.data.oracle.fields[0];
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        const [userAssetAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint,
+            owner: signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const ix = await (0, generated_1.getDepositInstructionAsync)({
+            signer,
+            permissions: generated_1.RLP_PROGRAM_ADDRESS,
+            liquidityPool: lpEntry.address,
+            lpToken: lpEntry.data.lpToken,
+            assetMint: mint,
+            userAssetAccount,
+            oracle: oracleAddress,
+            liquidityPoolIndex: liquidityPoolId,
+            amount,
+            minLpTokens: (minLpTokens ?? null),
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+        const remaining = await this.buildPoolValueRemainingAccounts(lpEntry.address, liquidityPoolId);
+        return this.appendRemainingAccounts(ix, remaining);
+    }
+    async requestWithdrawal(signer, liquidityPoolId, amount) {
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        const [cooldownAddress] = await PdaClient_1.PdaClient.deriveCooldown(liquidityPoolId, lpEntry.data.cooldowns);
+        const [signerLpTokenAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: lpEntry.data.lpToken,
+            owner: signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        return (0, generated_1.getRequestWithdrawalInstructionAsync)({
+            signer,
+            permissions: generated_1.RLP_PROGRAM_ADDRESS,
+            liquidityPool: lpEntry.address,
+            lpTokenMint: lpEntry.data.lpToken,
+            signerLpTokenAccount,
+            cooldown: cooldownAddress,
+            liquidityPoolId,
+            amount,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async withdraw(signer, liquidityPoolId, cooldownId) {
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        const [cooldownAddress] = await PdaClient_1.PdaClient.deriveCooldown(liquidityPoolId, cooldownId);
+        // audit-1: withdraw needs the signer's LP token account so any excess in
+        // the cooldown ATA can be refunded.
+        const [signerLpTokenAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: lpEntry.data.lpToken,
+            owner: signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const ix = await (0, generated_1.getWithdrawInstructionAsync)({
+            signer,
+            liquidityPool: lpEntry.address,
+            lpTokenMint: lpEntry.data.lpToken,
+            cooldown: cooldownAddress,
+            signerLpTokenAccount,
+            liquidityPoolId,
+            cooldownId,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+        const remaining = await this.buildWithdrawRemainingAccounts(signer, lpEntry.address, liquidityPoolId);
+        return this.appendRemainingAccounts(ix, remaining);
+    }
+    async swap(signer, liquidityPoolId, tokenFromMint, tokenToMint, amountIn, minOut) {
+        const assets = await this.getAssets();
+        const tokenFromEntry = assets.find((a) => a.data.mint === tokenFromMint);
+        if (!tokenFromEntry)
+            throw new Error(`Asset not found for mint ${tokenFromMint}`);
+        const tokenToEntry = assets.find((a) => a.data.mint === tokenToMint);
+        if (!tokenToEntry)
+            throw new Error(`Asset not found for mint ${tokenToMint}`);
+        const tokenFromOracle = tokenFromEntry.data.oracle
+            .fields[0];
+        const tokenToOracle = tokenToEntry.data.oracle
+            .fields[0];
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        const [tokenFromPool] = await (0, token_1.findAssociatedTokenPda)({
+            mint: tokenFromMint,
+            owner: lpEntry.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const [tokenToPool] = await (0, token_1.findAssociatedTokenPda)({
+            mint: tokenToMint,
+            owner: lpEntry.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const [tokenFromSignerAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: tokenFromMint,
+            owner: signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        const [tokenToSignerAccount] = await (0, token_1.findAssociatedTokenPda)({
+            mint: tokenToMint,
+            owner: signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        });
+        return (0, generated_1.getSwapInstructionAsync)({
+            signer,
+            liquidityPool: lpEntry.address,
+            tokenFrom: tokenFromMint,
+            tokenFromOracle,
+            tokenTo: tokenToMint,
+            tokenToOracle,
+            tokenFromPool,
+            tokenToPool,
+            tokenFromSignerAccount,
+            tokenToSignerAccount,
+            amountIn,
+            minOut: (minOut ?? null),
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async createPermissionAccount(caller, newAdmin) {
+        return (0, generated_1.getCreatePermissionAccountInstructionAsync)({
+            caller,
+            newAdmin,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async updateRoleHolder(admin, targetAddress, role, update) {
+        const [updateAdminPermissions] = await PdaClient_1.PdaClient.deriveUserPermissions(targetAddress);
+        return (0, generated_1.getUpdateRoleHolderInstructionAsync)({
+            admin,
+            updateAdminPermissions,
+            address: targetAddress,
+            role,
+            update,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async updateActionRole(admin, action, role, update) {
+        return (0, generated_1.getUpdateActionRoleInstructionAsync)({
+            admin,
+            action,
+            role,
+            update,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async updateDepositCap(signer, liquidityPoolId, newCap) {
+        const lpEntry = this.liquidityPools.find((lp) => lp.data.index === liquidityPoolId);
+        if (!lpEntry)
+            throw new Error(`Liquidity pool ${liquidityPoolId} not found`);
+        return (0, generated_1.getUpdateDepositCapInstructionAsync)({
+            signer,
+            liquidityPool: lpEntry.address,
+            lockupId: liquidityPoolId,
+            newCap: newCap,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async freezeFunctionality(admin, action, freeze) {
+        return (0, generated_1.getFreezeFunctionalityInstructionAsync)({
+            admin,
+            action,
+            freeze,
+            program: generated_1.RLP_PROGRAM_ADDRESS,
+        });
+    }
+    async findAssetFromMint(mint) {
+        const assets = await this.getAssets();
+        const entry = assets.find((a) => a.data.mint === mint);
+        if (!entry)
+            throw new Error(`Asset not found for mint ${mint}`);
+        return entry.address;
+    }
+    getSettings() {
+        return this.settings;
+    }
+    getCachedLiquidityPools() {
+        return this.liquidityPools;
+    }
+    getCachedAssets() {
+        return this.assets;
+    }
+    // ========================================================================
+    // Oracle
+    // ========================================================================
+    /**
+     * Fetch and deserialize the Pyth PriceUpdateV2 oracle account for a given
+     * asset, returning `{ price, exponent }` ready to pass into
+     * `simulateDepositMath`.
+     *
+     * @param mint  The asset mint whose oracle to read, OR a direct oracle
+     *              address.  When a mint is provided the oracle address is
+     *              looked up from the cached asset list.
+     */
+    async fetchOraclePrice(mintOrOracle) {
+        // Resolve oracle address — try cached assets first, fall back to treating
+        // the input as a direct oracle address.
+        let oracleAddress = mintOrOracle;
+        const assets = await this.getAssets();
+        const assetEntry = assets.find((a) => a.data.mint === mintOrOracle);
+        if (assetEntry) {
+            oracleAddress = assetEntry.data.oracle.fields[0];
+        }
+        const account = await (0, kit_1.fetchEncodedAccount)(this.connection, oracleAddress);
+        if (!account.exists) {
+            throw new Error(`Oracle account not found: ${oracleAddress}`);
+        }
+        return JuniorTranche.deserializePythPrice(new Uint8Array(account.data));
+    }
+    /**
+     * Deserialize a raw Pyth PriceUpdateV2 account buffer into price fields.
+     *
+     * Borsh layout (after 8-byte Anchor discriminator):
+     *   write_authority: Pubkey (32)
+     *   verification_level: Full=[1] (1 byte) | Partial=[0,u8] (2 bytes)
+     *   price_message {
+     *     feed_id: [u8;32], price: i64, conf: u64, exponent: i32,
+     *     publish_time: i64, ...
+     *   }
+     */
+    static deserializePythPrice(data) {
+        const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        // Skip 8-byte discriminator + 32-byte write_authority = offset 40
+        const verificationVariant = data[40];
+        // Full = 1 byte, Partial = 2 bytes (variant + num_signatures)
+        const verificationSize = verificationVariant === 0 ? 2 : 1;
+        const pmOffset = 40 + verificationSize; // start of price_message
+        // feed_id: 32 bytes, then price(i64), conf(u64), exponent(i32), publish_time(i64)
+        const priceOffset = pmOffset + 32;
+        const exponentOffset = priceOffset + 8 + 8; // after price + conf
+        const publishTimeOffset = exponentOffset + 4;
+        return {
+            price: dv.getBigInt64(priceOffset, true),
+            exponent: dv.getInt32(exponentOffset, true),
+            publishTime: dv.getBigInt64(publishTimeOffset, true),
+        };
+    }
+    // ========================================================================
+    // Simulation math
+    // ========================================================================
+    /**
+     * Simulate deposit math off-chain.
+     *
+     * Mirrors the on-chain logic in:
+     *   - `OraclePrice::mul`          (oracle_price.rs)
+     *   - `LiquidityPool::calculate_total_pool_value`
+     *   - `LiquidityPool::calculate_lp_tokens_on_deposit`
+     *
+     * @param depositAmount   Raw token amount to deposit (base units).
+     * @param depositAssetPrice  Oracle price of the deposit asset (`{ price, exponent }`).
+     * @param depositAssetDecimals  Decimals of the deposit token mint.
+     * @param poolReserves    Array of { balance, price, exponent, decimals } for every
+     *                        asset currently in the pool (BEFORE the deposit).
+     * @param lpTokenSupply   Current total supply of the LP token (includes dead shares).
+     * @param lpTokenDecimals Decimals of the LP token mint (typically 9).
+     * @returns               The number of LP tokens the depositor would receive (bigint).
+     */
+    static simulateDepositMath(params) {
+        const { depositAmount, depositAssetPrice, depositAssetDecimals, poolReserves, lpTokenSupply, lpTokenDecimals, } = params;
+        // --- PreciseNumber constants (mirrors spl-math) ---
+        const ONE = 1000000000000n; // 10^12
+        const HALF = ONE / 2n;
+        const PRECISION = 18;
+        // PreciseNumber::new(x) → x * ONE
+        const pNew = (x) => x * ONE;
+        // PreciseNumber::to_imprecise(v) → (v + HALF) / ONE
+        const pToU64 = (v) => (v + HALF) / ONE;
+        // PreciseNumber::checked_mul(a, b) → (a * b + HALF) / ONE
+        const pMul = (a, b) => (a * b + HALF) / ONE;
+        // PreciseNumber::checked_div(a, b) → (a * ONE + HALF) / b
+        const pDiv = (a, b) => (a * ONE + HALF) / b;
+        // PreciseNumber::checked_add(a, b) → a + b
+        const pAdd = (a, b) => a + b;
+        // --- OraclePrice::mul(amount, token_decimals) ---
+        const oracleMul = (price, exponent, amount, tokenDecimals) => {
+            const decimalAdj = PRECISION - tokenDecimals;
+            const normalizedAmount = amount * 10n ** BigInt(decimalAdj);
+            if (exponent >= 0) {
+                return normalizedAmount * price * 10n ** BigInt(exponent);
+            }
+            else {
+                return (normalizedAmount * price) / 10n ** BigInt(-exponent);
+            }
+        };
+        // --- calculate_total_pool_value ---
+        let totalPoolValue = pNew(0n); // precise
+        for (const r of poolReserves) {
+            if (r.balance > 0n) {
+                const rawValue = oracleMul(r.price, r.exponent, r.balance, r.decimals);
+                totalPoolValue = pAdd(totalPoolValue, pNew(rawValue));
+            }
+        }
+        // --- deposit_value ---
+        const rawDepositValue = oracleMul(depositAssetPrice.price, depositAssetPrice.exponent, depositAmount, depositAssetDecimals);
+        const depositValue = pNew(rawDepositValue); // precise
+        // --- calculate_lp_tokens_on_deposit ---
+        const poolValueImprecise = pToU64(totalPoolValue);
+        if (lpTokenSupply === 0n || poolValueImprecise === 0n) {
+            // Initial deposit formula: deposit_value / 10^(PRECISION - lp_decimals)
+            const scaleDown = pNew(10n ** BigInt(PRECISION - lpTokenDecimals));
+            return BigInt(pToU64(pDiv(depositValue, scaleDown)));
+        }
+        else {
+            // Proportional: deposit_value * lp_supply / total_pool_value
+            const lpSupplyPrecise = pNew(lpTokenSupply);
+            const ratio = pDiv(pMul(depositValue, lpSupplyPrecise), totalPoolValue);
+            return BigInt(pToU64(ratio));
+        }
+    }
+    /**
+     * Simulate withdrawal math off-chain.
+     *
+     * Mirrors the on-chain logic in `withdraw()` which computes:
+     *   `user_share_per_asset = reserve_amount * lp_token_amount / lp_token_supply`
+     *
+     * Uses PreciseNumber arithmetic to match on-chain rounding.
+     *
+     * @param lpTokenAmount   Amount of LP tokens the user is redeeming.
+     * @param lpTokenSupply   Current total supply of the LP token.
+     * @param reserves        Array of { mint, balance } for each pool asset.
+     * @returns               Array of { mint, amount } the user would receive per asset.
+     */
+    static simulateWithdrawMath(params) {
+        const { lpTokenAmount, lpTokenSupply, reserves } = params;
+        const ONE = 1000000000000n;
+        const HALF = ONE / 2n;
+        const pNew = (x) => x * ONE;
+        const pToU64 = (v) => (v + HALF) / ONE;
+        const pMul = (a, b) => (a * b + HALF) / ONE;
+        const pDiv = (a, b) => (a * ONE + HALF) / b;
+        return reserves.map((r) => {
+            // PreciseNumber(reserve) * PreciseNumber(lp_amount) / PreciseNumber(lp_supply)
+            const reservePrecise = pNew(r.balance);
+            const amountPrecise = pNew(lpTokenAmount);
+            const supplyPrecise = pNew(lpTokenSupply);
+            const share = pDiv(pMul(reservePrecise, amountPrecise), supplyPrecise);
+            return {
+                mint: r.mint,
+                amount: BigInt(pToU64(share)),
+            };
+        });
+    }
+}
+exports.JuniorTranche = JuniorTranche;