@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/jlpd-strategy/swap-jlp.js

@@ -0,0 +1,586 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwapJlpIx = createSwapJlpIx;
+exports.getJupiterSwapQuote = getJupiterSwapQuote;
+exports.getJupiterSwapInstructions = getJupiterSwapInstructions;
+exports.buildSwapJlpTransaction = buildSwapJlpTransaction;
+exports.buildRebalanceTransaction = buildRebalanceTransaction;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const ata_1 = require("../common/ata");
+const bn_js_1 = __importDefault(require("bn.js"));
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+const accounts_1 = require("./accounts");
+const pda_2 = require("../p-stv-core/pda");
+const instructions_1 = require("../p-stv-core/instructions");
+const remaining_accounts_1 = require("../p-stv-core/remaining-accounts");
+const accounts_2 = require("../p-stv-core/accounts");
+const constants_2 = require("../p-stv-core/constants");
+const pda_3 = require("../elemental-lend/pda");
+const jupiter_lend_1 = require("../elemental-lend/jupiter-lend");
+const instructions_2 = require("../elemental-lend/instructions");
+const accounts_3 = require("../elemental-lend/accounts");
+/** Decode a Jupiter `JupiterSwapInstruction` into a `TransactionInstruction`. */
+function decodeJupiterInstruction(raw) {
+    return new web3_js_1.TransactionInstruction({
+        programId: new web3_js_1.PublicKey(raw.programId),
+        keys: raw.accounts.map((acc) => ({
+            pubkey: new web3_js_1.PublicKey(acc.pubkey),
+            isSigner: acc.isSigner,
+            isWritable: acc.isWritable,
+        })),
+        data: Buffer.from(raw.data, "base64"),
+    });
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const JUPITER_API_BASE = "https://api.jup.ag/swap/v1";
+/**
+ * Optional Jupiter API key, read once at module load time. When set,
+ * outbound Jupiter requests include an `x-api-key` header for higher rate
+ * limits. Read once instead of per-call so the env var is consistent across
+ * the lifetime of the process.
+ */
+const JUPITER_API_KEY = process.env.NEXT_PUBLIC_JUPITER_API_KEY ?? process.env.JUPITER_API_KEY;
+function toBigInt(v) {
+    if (typeof v === "bigint")
+        return v;
+    const bn = v;
+    if (typeof bn.toBigInt === "function")
+        return bn.toBigInt();
+    return BigInt(bn.toString());
+}
+// ---------------------------------------------------------------------------
+// Low-level instruction builder
+// ---------------------------------------------------------------------------
+/**
+ * Build the on-chain `swap_jlp` instruction.
+ *
+ * Instruction data layout (Anchor Borsh):
+ *   [8-byte disc, 1-byte direction, 8-byte amount (LE), 8-byte min_out (LE),
+ *    4-byte jupiter_data_len (LE), ...jupiter_data_bytes]
+ */
+function createSwapJlpIx(args, programId = constants_1.PROGRAM_ID) {
+    const { manager, config, managerRole, strategyState, strategyBaseAta, strategyJlpAta, vaultJlpAta, baseMint, jlpMint, tokenProgram, jupiterProgram, priceOracle, jlpPool, jlpMintAccount, direction, amount, minOut, jupiterData, remainingAccounts = [], } = args;
+    const amountBi = toBigInt(amount);
+    const minOutBi = toBigInt(minOut);
+    // Serialize instruction data
+    const jupBytes = Buffer.from(jupiterData);
+    const dataLen = 8 + 1 + 8 + 8 + 4 + jupBytes.length;
+    const data = Buffer.alloc(dataLen);
+    // Discriminator
+    constants_1.IX_SWAP_JLP.copy(data, 0);
+    // Direction (1 byte)
+    data.writeUInt8(direction === "BaseToJlp" ? 0 : 1, 8);
+    // Amount (u64 LE)
+    data.writeBigUInt64LE(amountBi, 9);
+    // MinOut (u64 LE)
+    data.writeBigUInt64LE(minOutBi, 17);
+    // Jupiter data length (u32 LE) + bytes
+    data.writeUInt32LE(jupBytes.length, 25);
+    jupBytes.copy(data, 29);
+    const keys = [
+        { pubkey: manager, isSigner: true, isWritable: false },
+        { pubkey: config, isSigner: false, isWritable: false },
+        { pubkey: managerRole, isSigner: false, isWritable: false },
+        { pubkey: strategyState, isSigner: false, isWritable: true },
+        { pubkey: strategyBaseAta, isSigner: false, isWritable: true },
+        { pubkey: strategyJlpAta, isSigner: false, isWritable: true },
+        { pubkey: vaultJlpAta, isSigner: false, isWritable: true },
+        { pubkey: baseMint, isSigner: false, isWritable: false },
+        { pubkey: jlpMint, isSigner: false, isWritable: false },
+        { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        { pubkey: jupiterProgram, isSigner: false, isWritable: false },
+        { pubkey: priceOracle, isSigner: false, isWritable: false },
+        { pubkey: jlpPool, isSigner: false, isWritable: false },
+        { pubkey: jlpMintAccount, isSigner: false, isWritable: false },
+        ...remainingAccounts,
+    ];
+    return new web3_js_1.TransactionInstruction({ keys, programId, data });
+}
+// ---------------------------------------------------------------------------
+// Stable-asset detection
+// ---------------------------------------------------------------------------
+/** Mints that use a hardcoded $1 price on-chain (oracle account ignored). */
+const STABLE_MINTS = new Set(constants_1.JLPD_POOLS.filter((p) => p.name === "USDC" || p.name === "JupUSD").map((p) => p.mint));
+function isStableMint(mint) {
+    return STABLE_MINTS.has(mint.toBase58());
+}
+// ---------------------------------------------------------------------------
+// Jupiter API helpers
+// ---------------------------------------------------------------------------
+/**
+ * Fetch a swap quote from Jupiter's v1 quote API.
+ */
+async function getJupiterSwapQuote(args) {
+    const { inputMint, outputMint, amount, slippageBps = 50, maxAccounts = 40 } = args;
+    const params = new URLSearchParams({
+        inputMint: inputMint.toBase58(),
+        outputMint: outputMint.toBase58(),
+        amount: amount.toString(),
+        slippageBps: slippageBps.toString(),
+        maxAccounts: maxAccounts.toString(),
+    });
+    const url = `${JUPITER_API_BASE}/quote?${params.toString()}`;
+    const headers = {};
+    if (JUPITER_API_KEY) {
+        headers["x-api-key"] = JUPITER_API_KEY;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Jupiter quote API error (${response.status}): ${text}`);
+    }
+    const data = (await response.json());
+    if (data.error) {
+        throw new Error(`Jupiter quote error: ${data.error}`);
+    }
+    return data;
+}
+/**
+ * Fetch swap instructions from Jupiter's v1 swap-instructions API.
+ *
+ * @param quoteResponse The quote from getJupiterSwapQuote
+ * @param userPublicKey The account that signs the swap -- for JLPD this is the strategy_state PDA
+ * @param destinationTokenAccount Optional override for the destination token account.
+ *   For base_to_base_swap: must be base_out_ata (ATA owned by strategy_state_OUT) so
+ *   Jupiter routes output tokens there instead of to userPublicKey's default ATA.
+ *   For swap_jlp: omit — Jupiter defaults destination to userPublicKey's ATA which is correct.
+ */
+async function getJupiterSwapInstructions(args) {
+    const { quoteResponse, userPublicKey, destinationTokenAccount } = args;
+    const url = `${JUPITER_API_BASE}/swap-instructions`;
+    const body = {
+        quoteResponse,
+        userPublicKey: userPublicKey.toBase58(),
+        wrapAndUnwrapSol: false,
+        dynamicComputeUnitLimit: true,
+        skipUserAccountsRpcCalls: true,
+    };
+    if (destinationTokenAccount !== undefined) {
+        body["destinationTokenAccount"] = destinationTokenAccount.toBase58();
+    }
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (JUPITER_API_KEY) {
+        headers["x-api-key"] = JUPITER_API_KEY;
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Jupiter swap-instructions API error (${response.status}): ${text}`);
+    }
+    const data = (await response.json());
+    if (data.error) {
+        throw new Error(`Jupiter swap-instructions error: ${data.error}`);
+    }
+    // Extract the raw instruction data (base64 encoded) from the swap instruction
+    const swapIx = data.swapInstruction;
+    const swapInstructionData = Buffer.from(swapIx.data, "base64");
+    // Build remaining accounts from the swap instruction's accounts
+    // All signers become non-signers for CPI (the strategy PDA signs via seeds)
+    const remainingAccounts = swapIx.accounts.map((acc) => ({
+        pubkey: new web3_js_1.PublicKey(acc.pubkey),
+        isSigner: false,
+        isWritable: acc.isWritable,
+    }));
+    // Decode Jupiter's compute-budget instructions so callers can prepend them.
+    // Dropping these silently would leave the tx with the wrong CU budget and
+    // risk simulation/execution failure on complex routes.
+    const computeBudgetInstructions = (data.computeBudgetInstructions ?? []).map(decodeJupiterInstruction);
+    return {
+        swapInstructionData,
+        remainingAccounts,
+        addressLookupTableAddresses: data.addressLookupTableAddresses,
+        computeBudgetInstructions,
+    };
+}
+/**
+ * Fetch Address Lookup Tables from the chain.
+ */
+async function fetchAddressLookupTables(connection, addresses) {
+    if (addresses.length === 0)
+        return [];
+    const pubkeys = addresses.map((addr) => new web3_js_1.PublicKey(addr));
+    const accountInfos = await connection.getMultipleAccountsInfo(pubkeys);
+    const tables = [];
+    for (let i = 0; i < accountInfos.length; i++) {
+        const info = accountInfos[i];
+        if (!info) {
+            console.warn(`ALT not found: ${addresses[i]}`);
+            continue;
+        }
+        tables.push(new web3_js_1.AddressLookupTableAccount({
+            key: pubkeys[i],
+            state: web3_js_1.AddressLookupTableAccount.deserialize(info.data),
+        }));
+    }
+    return tables;
+}
+// ---------------------------------------------------------------------------
+// High-level builder
+// ---------------------------------------------------------------------------
+/**
+ * Build a complete swap_jlp transaction with Jupiter quote + instructions + ALTs.
+ *
+ * This is the main function the frontend calls. It:
+ * 1. Derives all PDAs (config, manager_role, strategy_state, ATAs)
+ * 2. Gets Jupiter quote
+ * 3. Gets Jupiter swap instructions
+ * 4. Builds the swap_jlp instruction with remaining accounts
+ * 5. Returns instructions + ALTs for a versioned transaction
+ */
+async function buildSwapJlpTransaction(args) {
+    const { connection, manager, baseMint, direction, amount, slippageBps = 50, jlpMint = constants_1.JLP_MINT, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, programId = constants_1.PROGRAM_ID, } = args;
+    // 1. Derive PDAs
+    const [config] = (0, pda_1.findJlpdConfigPda)(programId);
+    const [managerRole] = (0, pda_1.findJlpdManagerRolePda)(config, manager, programId);
+    const [strategyState] = (0, pda_1.findStrategyStatePda)(baseMint, programId);
+    // Derive ATAs
+    const strategyBaseAta = (0, ata_1.findAta)(baseMint, strategyState, tokenProgram);
+    const strategyJlpAta = (0, ata_1.findAta)(jlpMint, strategyState, tokenProgram);
+    const vaultJlpAta = (0, ata_1.findAta)(jlpMint, config, tokenProgram);
+    // 2. Resolve oracle + pending swap_arb. Use pre-fetched state when available;
+    //    otherwise fetch once if needed (volatile asset without oracle override, or BaseToJlp).
+    const needOracleFetch = !isStableMint(baseMint) && args.priceOracle === undefined;
+    const needArb = direction === "BaseToJlp";
+    const state = args.prefetchedStrategyState !== undefined
+        ? args.prefetchedStrategyState
+        : needOracleFetch || needArb
+            ? await (0, accounts_1.fetchJlpStrategyState)(connection, baseMint, programId)
+            : null;
+    let priceOracle;
+    if (isStableMint(baseMint)) {
+        priceOracle = web3_js_1.PublicKey.default;
+    }
+    else if (args.priceOracle !== undefined) {
+        priceOracle = args.priceOracle;
+    }
+    else {
+        priceOracle = state.priceOracle;
+    }
+    // 3. BaseToJlp folds pending swap_arb into the Jupiter input:
+    //    total_in = amount + swap_arb (signed; an unfavorable b2b banked a negative
+    //    deficit that reduces it). The on-chain handler pins base-spent == total_in,
+    //    so the Jupiter route MUST be quoted for total_in. The instruction `amount`
+    //    stays = principal (the program credits base_loaned with principal only).
+    let quoteAmount = amount;
+    if (direction === "BaseToJlp" && state) {
+        const arb = BigInt(state.swapArb.toString()); // signed i64
+        const totalIn = amount + arb;
+        if (totalIn <= 0n) {
+            throw new Error(`swap_arb deficit (${arb}) cancels principal (${amount}); cannot Base->JLP — wait for a settle or larger amount.`);
+        }
+        quoteAmount = totalIn;
+    }
+    // 4. Determine input/output mints for the Jupiter quote
+    const inputMint = direction === "BaseToJlp" ? baseMint : jlpMint;
+    const outputMint = direction === "BaseToJlp" ? jlpMint : baseMint;
+    // 5. Get Jupiter quote (for total_in on BaseToJlp; principal otherwise)
+    const quote = await getJupiterSwapQuote({
+        inputMint,
+        outputMint,
+        amount: quoteAmount,
+        slippageBps,
+    });
+    // 5. Get Jupiter swap instructions (strategy_state PDA signs via CPI)
+    const jupSwap = await getJupiterSwapInstructions({
+        quoteResponse: quote,
+        userPublicKey: strategyState,
+    });
+    // 6. Build the swap_jlp instruction
+    const minOut = BigInt(quote.otherAmountThreshold);
+    const swapJlpIx = createSwapJlpIx({
+        manager,
+        config,
+        managerRole,
+        strategyState,
+        strategyBaseAta,
+        strategyJlpAta,
+        vaultJlpAta,
+        baseMint,
+        jlpMint,
+        tokenProgram,
+        jupiterProgram: constants_1.JUPITER_PROGRAM,
+        priceOracle,
+        jlpPool: constants_1.JLP_POOL_ACCOUNT,
+        jlpMintAccount: jlpMint,
+        direction,
+        amount,
+        minOut,
+        jupiterData: jupSwap.swapInstructionData,
+        remainingAccounts: jupSwap.remainingAccounts,
+    }, programId);
+    // 7. Fetch ALTs
+    const addressLookupTables = await fetchAddressLookupTables(connection, jupSwap.addressLookupTableAddresses);
+    // Prepend compute-budget instructions from Jupiter so the tx carries the
+    // correct CU budget for complex routes. Dropping them risks simulation/exec failure.
+    const instructions = [
+        ...jupSwap.computeBudgetInstructions,
+        swapJlpIx,
+    ];
+    return {
+        instructions,
+        addressLookupTables,
+        quoteInAmount: BigInt(quote.inAmount),
+        minOut,
+    };
+}
+/**
+ * Build a complete rebalance transaction set for JLPD strategy.
+ *
+ * For BaseToJlp: auto-detects liquidity location and builds
+ * deposit_to_strategy + swap_jlp (tries 1 tx, falls back to 2 if needed).
+ *
+ * For JlpToBase: builds swap_jlp + withdraw_from_strategy in 1 tx.
+ */
+async function buildRebalanceTransaction(args) {
+    const { connection, manager, baseMint, vaultId, direction, amount, slippageBps = 50, jlpMint = constants_1.JLP_MINT, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, programId = constants_1.PROGRAM_ID, pStvProgramId = constants_2.PROGRAM_ID, } = args;
+    if (direction === "BaseToJlp") {
+        return buildBaseToJlpRebalance({
+            connection, manager, baseMint, vaultId, amount, slippageBps,
+            jlpMint, tokenProgram, programId, pStvProgramId,
+            liquidity: args.liquidity,
+        });
+    }
+    else {
+        return buildJlpToBaseRebalance({
+            connection, manager, baseMint, vaultId, amount, slippageBps,
+            jlpMint, tokenProgram, programId, pStvProgramId,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// BaseToJlp: deposit_to_strategy (if needed) + swap_jlp
+// ---------------------------------------------------------------------------
+async function buildBaseToJlpRebalance(args) {
+    const { connection, manager, baseMint, vaultId, amount, slippageBps, jlpMint, tokenProgram, programId, pStvProgramId, liquidity, } = args;
+    // Derive JLPD PDAs
+    const [strategyState] = (0, pda_1.findStrategyStatePda)(baseMint, programId);
+    const strategyBaseAta = (0, ata_1.findAta)(baseMint, strategyState, tokenProgram);
+    // Check if strategy_base_ata already has enough.
+    // Fix 4(c): when balance is not pre-supplied, batch the strategyBaseAta RPC fetch
+    // with the strategy-state fetch (which buildSwapJlpTransaction would make anyway
+    // for non-stable assets). This collapses two sequential RPC calls into one parallel batch.
+    let strategyBalance = liquidity?.strategyAtaBalance ?? 0n;
+    let prefetchedStrategyState;
+    if (!liquidity) {
+        const needStateFetch = !isStableMint(baseMint);
+        const [ataInfo, stateResult] = await Promise.all([
+            connection.getAccountInfo(strategyBaseAta).catch(() => null),
+            needStateFetch
+                ? (0, accounts_1.fetchJlpStrategyState)(connection, baseMint, programId)
+                : Promise.resolve(undefined),
+        ]);
+        if (ataInfo && ataInfo.data.length >= 72 && ataInfo.owner.equals(tokenProgram)) {
+            // PERF-LOW: read via subarray to avoid a full Buffer copy just to read 8 bytes.
+            strategyBalance = Buffer.from(ataInfo.data).subarray(64, 72).readBigUInt64LE(0);
+        }
+        if (stateResult !== undefined) {
+            prefetchedStrategyState = stateResult;
+        }
+    }
+    // Build the swap_jlp instruction (Jupiter quotes the exact inAmount).
+    // Thread pre-fetched strategy state when available to skip its internal fetch.
+    const { instructions: swapIxs, addressLookupTables, quoteInAmount } = await buildSwapJlpTransaction({
+        connection, manager, baseMint, direction: "BaseToJlp",
+        amount, slippageBps, jlpMint, tokenProgram, programId,
+        prefetchedStrategyState,
+    });
+    if (strategyBalance >= quoteInAmount) {
+        // Path 1: strategy_base_ata has enough — just swap
+        return {
+            preInstructions: [],
+            instructions: swapIxs,
+            postInstructions: [],
+            addressLookupTables,
+            routeDescription: "Direct swap (strategy has funds)",
+        };
+    }
+    // Path 2/3: Need to deposit_to_strategy first (auto-unsweep from lend)
+    // Use quoteInAmount (what Jupiter will actually consume) instead of the
+    // user's requested amount, to avoid leaving dust in the strategy ATA.
+    const deficit = quoteInAmount - strategyBalance;
+    // Fetch STV on-chain for lend info
+    const stv = await (0, accounts_2.fetchStv)(connection, vaultId, pStvProgramId);
+    const [stvAddress] = (0, pda_2.findStvPda)(vaultId, pStvProgramId);
+    const [stvManagerRole] = (0, pda_2.findStvManagerRolePda)(stvAddress, manager, pStvProgramId);
+    // Build deposit_to_strategy remaining accounts (lend + auto-unroute)
+    const vaultInfo = {
+        address: stvAddress,
+        baseMint,
+        lendProgram: stv.lendProgram,
+        strategy: stv.strategy,
+    };
+    const depositCtx = await (0, remaining_accounts_1.buildDepositToStrategyContext)(connection, vaultInfo);
+    // Derive the JLPD strategy's position PDA in p-STV Core
+    const [jlpdStvPosition] = (0, pda_1.findStvPositionPda)(stvAddress, programId);
+    const vaultAta = (0, ata_1.findAta)(baseMint, stvAddress, tokenProgram);
+    const [configPda] = (0, pda_2.findConfigPda)(pStvProgramId);
+    const depositIx = (0, instructions_1.createDepositToStrategyIx)({
+        manager,
+        managerRole: stvManagerRole,
+        config: configPda,
+        stv: stvAddress,
+        vaultAta,
+        baseMint,
+        strategyProgram: programId,
+        strategyState,
+        stvPosition: jlpdStvPosition,
+        strategyBaseAta,
+        tokenProgram,
+        amount: new bn_js_1.default(deficit.toString()),
+        minShares: new bn_js_1.default(0),
+        protocolAumCount: depositCtx.protocolAumCount,
+        autoUnrouteCount: depositCtx.autoUnrouteCount,
+        remainingAccounts: depositCtx.remainingAccounts,
+    }, pStvProgramId);
+    const allPreIxs = [...depositCtx.preInstructions, depositIx];
+    return {
+        preInstructions: allPreIxs,
+        instructions: swapIxs,
+        postInstructions: [],
+        addressLookupTables,
+        routeDescription: depositCtx.autoUnrouteCount > 0
+            ? "Unsweep from lend → deposit to strategy → swap"
+            : "Deposit to strategy → swap",
+    };
+}
+// ---------------------------------------------------------------------------
+// JlpToBase: swap_jlp + withdraw_from_strategy
+// ---------------------------------------------------------------------------
+async function buildJlpToBaseRebalance(args) {
+    const { connection, manager, baseMint, vaultId, amount, slippageBps, jlpMint, tokenProgram, programId, pStvProgramId, } = args;
+    const [strategyState] = (0, pda_1.findStrategyStatePda)(baseMint, programId);
+    const [stvAddress] = (0, pda_2.findStvPda)(vaultId, pStvProgramId);
+    // FIX 2: Fetch strategy state first (for oracle/prefetch perf win on non-stables),
+    // then build the Jupiter swap concurrently with the independent stv fetch.
+    // The position fetch is deferred until AFTER the swap result is known so that
+    // sharesToWithdraw is computed from a position read taken after the Jupiter
+    // quote/minOut is resolved — preserving the freshness semantics of the old code.
+    const stratState = await (0, accounts_1.fetchJlpStrategyState)(connection, baseMint, programId);
+    // Run Jupiter build (uses pre-fetched stratState for oracle) concurrently with
+    // the stv fetch (which does not depend on the quote outcome).
+    const [swapResult, stv] = await Promise.all([
+        buildSwapJlpTransaction({
+            connection, manager, baseMint, direction: "JlpToBase",
+            amount, slippageBps, jlpMint, tokenProgram, programId,
+            prefetchedStrategyState: stratState,
+        }),
+        (0, accounts_2.fetchStv)(connection, vaultId, pStvProgramId),
+    ]);
+    const { instructions: swapIxs, addressLookupTables, minOut: minBaseOut } = swapResult;
+    // FIX 1: minOut is returned explicitly by buildSwapJlpTransaction — no need to
+    // locate and parse the swap_jlp ix inside swapIxs by index.  The instruction
+    // array can start with compute-budget ixs (prepended by buildSwapJlpTransaction),
+    // so swapIxs[0] is not guaranteed to be the swap_jlp instruction.
+    // FIX 2 (continued): Fetch position AFTER the quote is resolved so sharesToWithdraw
+    // is computed from the freshest on-chain data, matching the pre-refactor behavior
+    // where the position read happened after the Jupiter network round-trip.
+    const position = await (0, accounts_1.fetchJlpStvPosition)(connection, stvAddress, programId);
+    // shares = ceil(minBaseOut * PPS_DECIMALS / pps), capped at position balance
+    // Use the fresh pps from stratState (fetched above) — acceptable here because pps
+    // changes only on settle_yield (infrequent) and stratState is fetched at the top
+    // of this function before the Jupiter quote begins.
+    const pps = BigInt(stratState.pps.toString());
+    const ppsDecimals = BigInt(constants_1.PPS_DECIMALS);
+    let sharesToWithdraw = (minBaseOut * ppsDecimals + pps - 1n) / pps;
+    const positionShares = BigInt(position.shares.toString());
+    if (sharesToWithdraw > positionShares) {
+        sharesToWithdraw = positionShares;
+    }
+    // Build withdraw_from_strategy
+    const [stvManagerRole] = (0, pda_2.findStvManagerRolePda)(stvAddress, manager, pStvProgramId);
+    const [jlpdStvPosition] = (0, pda_1.findStvPositionPda)(stvAddress, programId);
+    const strategyBaseAta = (0, ata_1.findAta)(baseMint, strategyState, tokenProgram);
+    const vaultAta = (0, ata_1.findAta)(baseMint, stvAddress, tokenProgram);
+    // Build lend remaining_accounts for auto-sweep after withdraw:
+    //   [4 fixed lend, protocolAumCount protocol-AUM accounts]
+    // The protocol-AUM accounts feed the pre-sweep update_aum refresh; on-chain lend
+    // rejects an incomplete tail, so we must cover the strategy's full protocol set.
+    const lendAccounts = [];
+    let lendProtocolAumCount = 0;
+    const DEFAULT_PUBKEY = web3_js_1.PublicKey.default;
+    if (!stv.lendProgram.equals(DEFAULT_PUBKEY)) {
+        const [lendStrategyState] = (0, pda_3.findStrategyStatePda)(baseMint, stv.lendProgram);
+        const [lendPosition] = (0, pda_3.findStvPositionPda)(stvAddress, stv.lendProgram);
+        const lendBaseAta = (0, ata_1.findAta)(baseMint, lendStrategyState, tokenProgram);
+        lendAccounts.push(...(0, instructions_1.buildLendRemainingAccounts)({
+            lendProgram: stv.lendProgram,
+            lendStrategyState,
+            lendStvPosition: lendPosition,
+            lendBaseAta,
+        }));
+        const lendState = await (0, accounts_3.fetchLendStrategyState)(connection, baseMint, stv.lendProgram).catch(() => null);
+        if (lendState) {
+            const protocolAumAccounts = await (0, accounts_3.buildProtocolAccountsForAum)(connection, lendState, lendStrategyState, tokenProgram);
+            lendProtocolAumCount = protocolAumAccounts.length;
+            lendAccounts.push(...protocolAumAccounts);
+        }
+    }
+    const [configPda] = (0, pda_2.findConfigPda)(pStvProgramId);
+    const withdrawIx = (0, instructions_1.createWithdrawFromStrategyIx)({
+        manager,
+        managerRole: stvManagerRole,
+        config: configPda,
+        stv: stvAddress,
+        vaultAta,
+        baseMint,
+        strategyProgram: programId,
+        strategyState,
+        stvPosition: jlpdStvPosition,
+        strategyBaseAta,
+        tokenProgram,
+        shares: new bn_js_1.default(sharesToWithdraw.toString()),
+        protocolAumCount: lendProtocolAumCount,
+        remainingAccounts: lendAccounts,
+    }, pStvProgramId);
+    // Build Jupiter Lend deposit instruction to route funds from Elemental Lend → Jupiter Lend.
+    // After withdraw_from_strategy, funds are swept to Elemental Lend's base ATA.
+    // This instruction routes them into the Jupiter Lend pool for yield.
+    const postInstructions = [];
+    const jupPool = jupiter_lend_1.JUP_LEND_POOLS[baseMint.toBase58()];
+    if (!stv.lendProgram.equals(DEFAULT_PUBKEY) && jupPool) {
+        const lendProgramId = stv.lendProgram;
+        const [lendStrategyState] = (0, pda_3.findStrategyStatePda)(baseMint, lendProgramId);
+        const [lendManagerRole] = (0, pda_3.findLendManagerRolePda)(lendStrategyState, manager, lendProgramId);
+        const lendBaseAta = (0, ata_1.findAta)(baseMint, lendStrategyState, tokenProgram);
+        const lendFtokenAta = (0, ata_1.findAta)(jupPool.fTokenMint, lendStrategyState, tokenProgram);
+        const JUP_LEND_PROG = new web3_js_1.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
+        const jupLendAccounts = [
+            ...(0, jupiter_lend_1.buildJupLendDepositAccounts)(jupPool, lendStrategyState, lendBaseAta, lendFtokenAta).map((a) => ({ ...a, isSigner: false })),
+            { pubkey: JUP_LEND_PROG, isSigner: false, isWritable: false },
+        ];
+        // Use minBaseOut as the deposit amount — this is the minimum base tokens
+        // that will arrive in the lend base ATA after swap → withdraw → sweep.
+        // The actual amount may be slightly higher due to favorable slippage.
+        postInstructions.push((0, instructions_2.createJupLendDepositIx)({
+            manager,
+            strategyState: lendStrategyState,
+            managerRole: lendManagerRole,
+            depositorBaseAta: lendBaseAta,
+            depositorFtokenAta: lendFtokenAta,
+            amount: new bn_js_1.default(minBaseOut.toString()),
+            remainingAccounts: jupLendAccounts,
+        }, lendProgramId));
+    }
+    return {
+        preInstructions: [],
+        instructions: [...swapIxs, withdrawIx],
+        postInstructions,
+        addressLookupTables,
+        routeDescription: jupPool
+            ? "Swap JLP → base → withdraw to vault → route to Jupiter Lend"
+            : "Swap JLP → base → withdraw to vault",
+    };
+}

package/dist/jlpd-strategy/types.d.ts

@@ -0,0 +1,101 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import type { StrategyStateHeader } from "../common/strategy-interface";
+/**
+ * JlpdConfig global config (392 bytes total, 384 data bytes after the 8-byte
+ * discriminator). Layout mirrors `jlpd_config.rs`'s CURRENT `JlpdConfig`
+ * struct — the retired adapter-era fields (`jlp_earn_amount`,
+ * `jlp_adapter_program`) are GONE; that byte range is now split between the
+ * divergence-breaker fields and `_reserved`.
+ */
+export interface JlpdConfig {
+    admin: PublicKey;
+    jlpMint: PublicKey;
+    baseAssetMints: PublicKey[];
+    oracleStalenessTh: BN;
+    flags: number;
+    jlpSlippageBps: number;
+    version: number;
+    bump: number;
+    /**
+     * Divergence-breaker SOFT band (bps): settle emits `LiveAumDivergence`
+     * (no revert) above this. `0` (an existing pre-upgrade account, or an
+     * admin who never tuned it) resolves to the 1% default — see
+     * `softBreakerTolBpsResolved`.
+     */
+    softBreakerTolBps: number;
+    /**
+     * Divergence-breaker HARD band (bps): settle reverts `AumDivergenceExceeded`
+     * above this. `0` resolves to the 3% default — see `aumHardBreakerBpsResolved`.
+     */
+    aumHardBreakerBps: number;
+    /**
+     * Canonical vault JLP ATA = ATA(config, jlp_mint, token_program); write-once
+     * at init, pinned immutable.
+     */
+    vaultJlpAta: PublicKey;
+    /**
+     * Per-`StrategyState` cap on banked `swap_arb` (USD 6-dec); `0` ⇒ fail-closed
+     * (no positive arb) until the admin sets it.
+     */
+    maxSwapArbUsdPerAsset: BN;
+}
+/** Upper bound for either divergence-breaker band (100%). Only bounds an admin typo. */
+export declare const MAX_BREAKER_BPS = 10000;
+/** Default soft-breaker band (1%), applied when the stored field reads `0` or `> MAX_BREAKER_BPS`. */
+export declare const DEFAULT_SOFT_BREAKER_TOL_BPS = 100;
+/** Default hard-breaker band (3%), applied when the stored field reads `0` or `> MAX_BREAKER_BPS`. */
+export declare const DEFAULT_AUM_HARD_BREAKER_BPS = 300;
+/**
+ * Resolved soft-breaker band: the stored value, or `DEFAULT_SOFT_BREAKER_TOL_BPS`
+ * when the stored value is `0` or exceeds `MAX_BREAKER_BPS` — mirrors
+ * `JlpdConfig::soft_breaker_tol_bps_resolved` exactly.
+ */
+export declare function softBreakerTolBpsResolved(config: Pick<JlpdConfig, "softBreakerTolBps">): number;
+/**
+ * Resolved hard-breaker band: the stored value, or `DEFAULT_AUM_HARD_BREAKER_BPS`
+ * when the stored value is `0` or exceeds `MAX_BREAKER_BPS` — mirrors
+ * `JlpdConfig::aum_hard_breaker_bps_resolved` exactly.
+ */
+export declare function aumHardBreakerBpsResolved(config: Pick<JlpdConfig, "aumHardBreakerBps">): number;
+/** ManagerRole PDA (80 bytes) — grants manager access to rebalance operations */
+export interface ManagerRole {
+    config: PublicKey;
+    manager: PublicKey;
+    bump: number;
+}
+/** JLP StrategyState (224 bytes) — extends standard 104-byte header */
+export interface JlpStrategyState extends StrategyStateHeader {
+    baseLoaned: BN;
+    swapArb: BN;
+    priceOracle: PublicKey;
+}
+export type { StvPosition } from "../common/strategy-interface";
+export interface ConfigInitializedEvent {
+    name: "ConfigInitialized";
+    config: PublicKey;
+    admin: PublicKey;
+    jlpMint: PublicKey;
+}
+export interface ConfigUpdatedEvent {
+    name: "ConfigUpdated";
+    config: PublicKey;
+    oldAdmin: PublicKey;
+    newAdmin: PublicKey;
+    oldFlags: number;
+    newFlags: number;
+    oldJlpSlippageBps: number;
+    newJlpSlippageBps: number;
+    oldOracleStalenessTh: BN;
+    newOracleStalenessTh: BN;
+}
+export interface ManagerAddedEvent {
+    name: "ManagerAdded";
+    config: PublicKey;
+    manager: PublicKey;
+}
+export interface ManagerRemovedEvent {
+    name: "ManagerRemoved";
+    config: PublicKey;
+    manager: PublicKey;
+}