@elmntl/jlpd-sdk 0.2.0 → 0.13.4

package/dist/elemental-lend/kamino-vault.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Kamino kVault account builders for deposit/withdraw.
+ *
+ * Builds the remaining_accounts arrays needed by elemental-lend's
+ * kvault_deposit and kvault_withdraw instructions.
+ *
+ * For deposit: 11 fixed accounts derived from vault_state PDAs.
+ * For withdraw: 21 fixed accounts — first 12 derivable, then 9 KLend-specific
+ *   accounts read from vault_state and reserve on-chain data.
+ */
+import { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { KLEND_PROGRAM } from "./constants";
+import type { SolanaConnection } from "../common/connection";
+export { KLEND_PROGRAM };
+/** Kamino Vault global config (singleton, mainnet) */
+export declare const KAMINO_GLOBAL_CONFIG: PublicKey;
+/** Derive token_vault PDA: ["token_vault", vault_state] under Kamino Vault */
+export declare function findKvaultTokenVault(vaultState: PublicKey): [PublicKey, number];
+/** Derive base_vault_authority PDA: ["authority", vault_state] under Kamino Vault */
+export declare function findKvaultAuthority(vaultState: PublicKey): [PublicKey, number];
+/** Derive shares_mint PDA: ["shares", vault_state] under Kamino Vault */
+export declare function findKvaultSharesMint(vaultState: PublicKey): [PublicKey, number];
+/** Derive event_authority PDA: ["__event_authority"] under Kamino Vault */
+export declare function findKvaultEventAuthority(): [PublicKey, number];
+/** Derive lending_market_authority PDA: ["lma", lending_market] under KLend */
+export declare function findLendingMarketAuthority(lendingMarket: PublicKey): [PublicKey, number];
+/**
+ * Read the first VaultAllocation's reserve and ctokenVault from VaultState data.
+ *
+ * @param vaultStateData - Raw account data (including 8-byte discriminator)
+ * @param allocationIndex - Which allocation slot to read (default 0)
+ */
+export declare function readVaultAllocation(vaultStateData: Buffer | Uint8Array, allocationIndex?: number): {
+    reserve: PublicKey;
+    ctokenVault: PublicKey;
+};
+/**
+ * Read KLend-specific accounts from a Reserve account's raw data.
+ *
+ * @param reserveData - Raw KLend Reserve account data (including 8-byte discriminator)
+ */
+export declare function readReserveAccounts(reserveData: Buffer | Uint8Array): {
+    lendingMarket: PublicKey;
+    reserveLiquiditySupply: PublicKey;
+    reserveCollateralMint: PublicKey;
+    reserveCollateralTokenProgram: PublicKey;
+};
+/**
+ * Build the 11 remaining_accounts for elemental-lend's kvault_deposit instruction.
+ *
+ * Account order matches kamino_vault::deposit_accounts:
+ *   0.  strategy_state PDA (signer, mut)
+ *   1.  vault_state (mut)
+ *   2.  token_vault (mut) — PDA ["token_vault", vault_state]
+ *   3.  token_mint — base token mint
+ *   4.  base_vault_authority — PDA ["authority", vault_state]
+ *   5.  shares_mint (mut) — PDA ["shares", vault_state]
+ *   6.  user_token_ata (mut) — strategy's base ATA
+ *   7.  user_shares_ata (mut) — strategy's kvToken ATA
+ *   8.  klend_program
+ *   9.  token_program — SPL Token
+ *  10.  shares_token_program — SPL Token
+ *
+ * After the 11 fixed accounts, callers should append reserve accounts for refresh.
+ */
+export declare function buildKvaultDepositAccounts(vaultState: PublicKey, strategyStatePda: PublicKey, strategyBaseAta: PublicKey, strategySharesAta: PublicKey, baseMint: PublicKey, reserves?: {
+    reserve: PublicKey;
+    lendingMarket: PublicKey;
+}[]): AccountMeta[];
+/**
+ * KLend reserve accounts needed for kvault_withdraw.
+ * Read from vault_state and reserve on-chain data using
+ * readVaultAllocation() and readReserveAccounts().
+ */
+export interface KvaultWithdrawReserveConfig {
+    reserve: PublicKey;
+    ctokenVault: PublicKey;
+    lendingMarket: PublicKey;
+    lendingMarketAuthority: PublicKey;
+    reserveLiquiditySupply: PublicKey;
+    reserveCollateralMint: PublicKey;
+    reserveCollateralTokenProgram: PublicKey;
+}
+/**
+ * Build the KvaultWithdrawReserveConfig from raw on-chain data.
+ *
+ * @param vaultStateData - Raw Kamino VaultState account data
+ * @param reserveData - Raw KLend Reserve account data
+ * @param allocationIndex - VaultAllocation index (default 0)
+ */
+export declare function buildKvaultWithdrawReserveConfig(vaultStateData: Buffer | Uint8Array, reserveData: Buffer | Uint8Array, allocationIndex?: number): KvaultWithdrawReserveConfig;
+/**
+ * Build the 21 remaining_accounts for elemental-lend's kvault_withdraw instruction.
+ *
+ * Account order matches kamino_vault::withdraw_accounts:
+ *   WithdrawFromAvailable (0-11):
+ *     0.  strategy_state PDA (signer, mut)
+ *     1.  vault_state (mut)
+ *     2.  global_config
+ *     3.  token_vault (mut)
+ *     4.  base_vault_authority
+ *     5.  user_token_ata (mut) — strategy's base ATA
+ *     6.  token_mint (mut)
+ *     7.  user_shares_ata (mut) — strategy's kvToken ATA
+ *     8.  shares_mint (mut)
+ *     9.  token_program
+ *    10.  shares_token_program
+ *    11.  klend_program
+ *   WithdrawFromInvested (12-20):
+ *    12.  vault_state (mut, dup)
+ *    13.  reserve (mut)
+ *    14.  ctoken_vault (mut)
+ *    15.  lending_market
+ *    16.  lending_market_authority
+ *    17.  reserve_liquidity_supply (mut)
+ *    18.  reserve_collateral_mint (mut)
+ *    19.  reserve_collateral_token_program
+ *    20.  instruction_sysvar_account
+ *
+ * After the 21 fixed accounts, callers should append reserve accounts for refresh.
+ */
+export declare function buildKvaultWithdrawAccounts(vaultState: PublicKey, strategyStatePda: PublicKey, strategyBaseAta: PublicKey, strategySharesAta: PublicKey, baseMint: PublicKey, reserveConfig: KvaultWithdrawReserveConfig, globalConfig?: PublicKey): AccountMeta[];
+/** Staleness threshold in seconds (matches elemental-lend KVAULT_STALENESS_THRESHOLD) */
+export declare const KVAULT_STALENESS_THRESHOLD = 120;
+/**
+ * Read `last_fee_charge_timestamp` from raw Kamino VaultState account data.
+ * Returns undefined if data is too short.
+ */
+export declare function readKvaultLastFeeChargeTs(data: Buffer | Uint8Array): number | undefined;
+/**
+ * Check if a Kamino kVault is stale (needs an `invest` call to refresh).
+ *
+ * @param vaultStateData - Raw account data for the Kamino VaultState
+ * @param currentSlotTimestamp - Current cluster timestamp (seconds)
+ * @returns true if the vault is stale (last_fee_charge_timestamp is older than threshold)
+ */
+export declare function isKvaultStale(vaultStateData: Buffer | Uint8Array, currentSlotTimestamp: number): boolean;
+/**
+ * Check if any registered kVault protocol is stale and return the stale vault states.
+ *
+ * @param connection - Solana connection
+ * @param protocols - Protocol pubkeys from the lend strategy state
+ * @returns Array of stale kVault state pubkeys
+ */
+export declare function findStaleKvaults(connection: SolanaConnection, protocols: PublicKey[]): Promise<PublicKey[]>;
+/**
+ * Build a Kamino `invest` instruction to refresh a stale kVault.
+ *
+ * `invest` is permissionless — anyone can call it. It refreshes the vault's
+ * `last_fee_charge_timestamp` which is required for elemental-lend's update_aum
+ * staleness check (120s threshold).
+ *
+ * @param payer - Transaction signer (pays for any crank fee, usually 0)
+ * @param payerTokenAccount - Payer's base token ATA (for crank fee)
+ * @param vaultState - Kamino vault_state pubkey
+ * @param baseMint - Base token mint (e.g., USDC)
+ * @param vaultStateData - Raw vault_state account data (for reading allocation)
+ * @param reserveData - Raw KLend reserve account data (for reading lending_market, etc.)
+ * @param allocationIndex - Which vault allocation to invest (default 0)
+ */
+export declare function buildKaminoInvestIx(payer: PublicKey, payerTokenAccount: PublicKey, vaultState: PublicKey, baseMint: PublicKey, vaultStateData: Buffer | Uint8Array, reserveData: Buffer | Uint8Array, allocationIndex?: number): TransactionInstruction;
+/**
+ * Build Kamino `invest` instructions for all stale kVaults in a lend strategy.
+ *
+ * Checks each registered protocol for staleness and returns invest instructions
+ * for any that are stale.
+ *
+ * @param connection - Solana connection
+ * @param payer - Transaction signer
+ * @param baseMint - Base token mint
+ * @param protocols - Registered protocol pubkeys from lend strategy state
+ */
+export declare function buildKaminoInvestIxsIfStale(connection: SolanaConnection, payer: PublicKey, baseMint: PublicKey, protocols: PublicKey[]): Promise<TransactionInstruction[]>;

package/dist/elemental-lend/kamino-vault.js

@@ -0,0 +1,483 @@
+"use strict";
+/**
+ * Kamino kVault account builders for deposit/withdraw.
+ *
+ * Builds the remaining_accounts arrays needed by elemental-lend's
+ * kvault_deposit and kvault_withdraw instructions.
+ *
+ * For deposit: 11 fixed accounts derived from vault_state PDAs.
+ * For withdraw: 21 fixed accounts — first 12 derivable, then 9 KLend-specific
+ *   accounts read from vault_state and reserve on-chain data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KVAULT_STALENESS_THRESHOLD = exports.KAMINO_GLOBAL_CONFIG = exports.KLEND_PROGRAM = void 0;
+exports.findKvaultTokenVault = findKvaultTokenVault;
+exports.findKvaultAuthority = findKvaultAuthority;
+exports.findKvaultSharesMint = findKvaultSharesMint;
+exports.findKvaultEventAuthority = findKvaultEventAuthority;
+exports.findLendingMarketAuthority = findLendingMarketAuthority;
+exports.readVaultAllocation = readVaultAllocation;
+exports.readReserveAccounts = readReserveAccounts;
+exports.buildKvaultDepositAccounts = buildKvaultDepositAccounts;
+exports.buildKvaultWithdrawReserveConfig = buildKvaultWithdrawReserveConfig;
+exports.buildKvaultWithdrawAccounts = buildKvaultWithdrawAccounts;
+exports.readKvaultLastFeeChargeTs = readKvaultLastFeeChargeTs;
+exports.isKvaultStale = isKvaultStale;
+exports.findStaleKvaults = findStaleKvaults;
+exports.buildKaminoInvestIx = buildKaminoInvestIx;
+exports.buildKaminoInvestIxsIfStale = buildKaminoInvestIxsIfStale;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "KLEND_PROGRAM", { enumerable: true, get: function () { return constants_1.KLEND_PROGRAM; } });
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Kamino Vault global config (singleton, mainnet) */
+exports.KAMINO_GLOBAL_CONFIG = new web3_js_1.PublicKey("BKyTcUe6daNG8HbgBix2ugdRHbykG2dK9hPBBqhUyoEX");
+/** SPL Token program */
+const SPL_TOKEN_PROGRAM = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/** Sysvar Instructions */
+const SYSVAR_INSTRUCTIONS = new web3_js_1.PublicKey("Sysvar1nstructions1111111111111111111111111");
+// ---------------------------------------------------------------------------
+// PDA Derivation Helpers
+// ---------------------------------------------------------------------------
+/** Derive token_vault PDA: ["token_vault", vault_state] under Kamino Vault */
+function findKvaultTokenVault(vaultState) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token_vault"), vaultState.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+}
+/** Derive base_vault_authority PDA: ["authority", vault_state] under Kamino Vault */
+function findKvaultAuthority(vaultState) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("authority"), vaultState.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+}
+/** Derive shares_mint PDA: ["shares", vault_state] under Kamino Vault */
+function findKvaultSharesMint(vaultState) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("shares"), vaultState.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+}
+/** Derive event_authority PDA: ["__event_authority"] under Kamino Vault */
+function findKvaultEventAuthority() {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], constants_1.KAMINO_VAULT_PROGRAM);
+}
+/** Derive lending_market_authority PDA: ["lma", lending_market] under KLend */
+function findLendingMarketAuthority(lendingMarket) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("lma"), lendingMarket.toBuffer()], constants_1.KLEND_PROGRAM);
+}
+// ---------------------------------------------------------------------------
+// VaultState / Reserve Data Readers
+// ---------------------------------------------------------------------------
+/**
+ * Kamino VaultState layout offsets (from account data start, including 8-byte discriminator).
+ *
+ * VaultAllocation[0] starts at offset 312:
+ *   [312..344]  reserve (Pubkey)
+ *   [344..376]  ctokenVault (Pubkey)
+ *   Each VaultAllocation is 2160 bytes. Index N starts at 312 + N*2160.
+ */
+const VAULT_ALLOCATION_OFFSET = 312; // 8 disc + 304 struct offset
+const VAULT_ALLOCATION_SIZE = 2160;
+/**
+ * KLend Reserve layout offsets (from account data start, including 8-byte discriminator).
+ *   [32..64]     lendingMarket (Pubkey)
+ *   [160..192]   liquidity.supplyVault (Pubkey)
+ *   [408..440]   liquidity.tokenProgram (Pubkey)
+ *   [2560..2592] collateral.mintPubkey (Pubkey)
+ */
+const RESERVE_LENDING_MARKET_OFFSET = 32;
+const RESERVE_LIQUIDITY_SUPPLY_OFFSET = 160;
+const RESERVE_LIQUIDITY_TOKEN_PROGRAM_OFFSET = 408;
+const RESERVE_COLLATERAL_MINT_OFFSET = 2560;
+/** Read a Pubkey from a Buffer at a given offset */
+function readPubkey(data, offset) {
+    return new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+}
+/**
+ * Read the first VaultAllocation's reserve and ctokenVault from VaultState data.
+ *
+ * @param vaultStateData - Raw account data (including 8-byte discriminator)
+ * @param allocationIndex - Which allocation slot to read (default 0)
+ */
+function readVaultAllocation(vaultStateData, allocationIndex = 0) {
+    const base = VAULT_ALLOCATION_OFFSET + allocationIndex * VAULT_ALLOCATION_SIZE;
+    if (vaultStateData.length < base + 64) {
+        throw new Error(`VaultState data too short for allocation ${allocationIndex}: need ${base + 64}, got ${vaultStateData.length}`);
+    }
+    return {
+        reserve: readPubkey(vaultStateData, base),
+        ctokenVault: readPubkey(vaultStateData, base + 32),
+    };
+}
+/**
+ * Read KLend-specific accounts from a Reserve account's raw data.
+ *
+ * @param reserveData - Raw KLend Reserve account data (including 8-byte discriminator)
+ */
+function readReserveAccounts(reserveData) {
+    if (reserveData.length < RESERVE_COLLATERAL_MINT_OFFSET + 32) {
+        throw new Error(`Reserve data too short: need ${RESERVE_COLLATERAL_MINT_OFFSET + 32}, got ${reserveData.length}`);
+    }
+    return {
+        lendingMarket: readPubkey(reserveData, RESERVE_LENDING_MARKET_OFFSET),
+        reserveLiquiditySupply: readPubkey(reserveData, RESERVE_LIQUIDITY_SUPPLY_OFFSET),
+        reserveCollateralMint: readPubkey(reserveData, RESERVE_COLLATERAL_MINT_OFFSET),
+        reserveCollateralTokenProgram: readPubkey(reserveData, RESERVE_LIQUIDITY_TOKEN_PROGRAM_OFFSET),
+    };
+}
+// ---------------------------------------------------------------------------
+// Deposit Account Builder (11 fixed accounts)
+// ---------------------------------------------------------------------------
+/**
+ * Build the 11 remaining_accounts for elemental-lend's kvault_deposit instruction.
+ *
+ * Account order matches kamino_vault::deposit_accounts:
+ *   0.  strategy_state PDA (signer, mut)
+ *   1.  vault_state (mut)
+ *   2.  token_vault (mut) — PDA ["token_vault", vault_state]
+ *   3.  token_mint — base token mint
+ *   4.  base_vault_authority — PDA ["authority", vault_state]
+ *   5.  shares_mint (mut) — PDA ["shares", vault_state]
+ *   6.  user_token_ata (mut) — strategy's base ATA
+ *   7.  user_shares_ata (mut) — strategy's kvToken ATA
+ *   8.  klend_program
+ *   9.  token_program — SPL Token
+ *  10.  shares_token_program — SPL Token
+ *
+ * After the 11 fixed accounts, callers should append reserve accounts for refresh.
+ */
+function buildKvaultDepositAccounts(vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, reserves = []) {
+    const [tokenVault] = findKvaultTokenVault(vaultState);
+    const [authority] = findKvaultAuthority(vaultState);
+    const [sharesMint] = findKvaultSharesMint(vaultState);
+    const [eventAuthority] = findKvaultEventAuthority();
+    const accounts = [
+        { pubkey: strategyStatePda, isSigner: true, isWritable: true }, // 0
+        { pubkey: vaultState, isSigner: false, isWritable: true }, // 1
+        { pubkey: tokenVault, isSigner: false, isWritable: true }, // 2
+        { pubkey: baseMint, isSigner: false, isWritable: false }, // 3
+        { pubkey: authority, isSigner: false, isWritable: false }, // 4
+        { pubkey: sharesMint, isSigner: false, isWritable: true }, // 5
+        { pubkey: strategyBaseAta, isSigner: false, isWritable: true }, // 6
+        { pubkey: strategySharesAta, isSigner: false, isWritable: true }, // 7
+        { pubkey: constants_1.KLEND_PROGRAM, isSigner: false, isWritable: false }, // 8
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 9
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 10
+        { pubkey: eventAuthority, isSigner: false, isWritable: false }, // 11 (Anchor event CPI)
+        { pubkey: constants_1.KAMINO_VAULT_PROGRAM, isSigner: false, isWritable: false }, // 12 (program self-ref)
+    ];
+    // Append reserve accounts for KLend batch refresh (writable), then unique lending markets (readonly).
+    // Kamino's cpi_refresh_reserves uses .take(reserves_count) to get just the reserves,
+    // then reads lending_market from each reserve's data for the CPI. The lending_market
+    // AccountInfo must be in the transaction but after the reserves.
+    const seenMarkets = new Set();
+    for (const { reserve } of reserves) {
+        accounts.push({ pubkey: reserve, isSigner: false, isWritable: true });
+    }
+    for (const { lendingMarket } of reserves) {
+        const key = lendingMarket.toBase58();
+        if (!seenMarkets.has(key)) {
+            seenMarkets.add(key);
+            accounts.push({ pubkey: lendingMarket, isSigner: false, isWritable: false });
+        }
+    }
+    return accounts;
+}
+/**
+ * Build the KvaultWithdrawReserveConfig from raw on-chain data.
+ *
+ * @param vaultStateData - Raw Kamino VaultState account data
+ * @param reserveData - Raw KLend Reserve account data
+ * @param allocationIndex - VaultAllocation index (default 0)
+ */
+function buildKvaultWithdrawReserveConfig(vaultStateData, reserveData, allocationIndex = 0) {
+    const alloc = readVaultAllocation(vaultStateData, allocationIndex);
+    const res = readReserveAccounts(reserveData);
+    const [lendingMarketAuthority] = findLendingMarketAuthority(res.lendingMarket);
+    return {
+        reserve: alloc.reserve,
+        ctokenVault: alloc.ctokenVault,
+        lendingMarket: res.lendingMarket,
+        lendingMarketAuthority,
+        reserveLiquiditySupply: res.reserveLiquiditySupply,
+        reserveCollateralMint: res.reserveCollateralMint,
+        reserveCollateralTokenProgram: res.reserveCollateralTokenProgram,
+    };
+}
+/**
+ * Build the 21 remaining_accounts for elemental-lend's kvault_withdraw instruction.
+ *
+ * Account order matches kamino_vault::withdraw_accounts:
+ *   WithdrawFromAvailable (0-11):
+ *     0.  strategy_state PDA (signer, mut)
+ *     1.  vault_state (mut)
+ *     2.  global_config
+ *     3.  token_vault (mut)
+ *     4.  base_vault_authority
+ *     5.  user_token_ata (mut) — strategy's base ATA
+ *     6.  token_mint (mut)
+ *     7.  user_shares_ata (mut) — strategy's kvToken ATA
+ *     8.  shares_mint (mut)
+ *     9.  token_program
+ *    10.  shares_token_program
+ *    11.  klend_program
+ *   WithdrawFromInvested (12-20):
+ *    12.  vault_state (mut, dup)
+ *    13.  reserve (mut)
+ *    14.  ctoken_vault (mut)
+ *    15.  lending_market
+ *    16.  lending_market_authority
+ *    17.  reserve_liquidity_supply (mut)
+ *    18.  reserve_collateral_mint (mut)
+ *    19.  reserve_collateral_token_program
+ *    20.  instruction_sysvar_account
+ *
+ * After the 21 fixed accounts, callers should append reserve accounts for refresh.
+ */
+function buildKvaultWithdrawAccounts(vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, reserveConfig, globalConfig = exports.KAMINO_GLOBAL_CONFIG) {
+    const [tokenVault] = findKvaultTokenVault(vaultState);
+    const [authority] = findKvaultAuthority(vaultState);
+    const [sharesMint] = findKvaultSharesMint(vaultState);
+    const [eventAuthority] = findKvaultEventAuthority();
+    return [
+        // WithdrawFromAvailable (0-11)
+        { pubkey: strategyStatePda, isSigner: true, isWritable: true }, // 0
+        { pubkey: vaultState, isSigner: false, isWritable: true }, // 1
+        { pubkey: globalConfig, isSigner: false, isWritable: false }, // 2
+        { pubkey: tokenVault, isSigner: false, isWritable: true }, // 3
+        { pubkey: authority, isSigner: false, isWritable: false }, // 4
+        { pubkey: strategyBaseAta, isSigner: false, isWritable: true }, // 5
+        { pubkey: baseMint, isSigner: false, isWritable: true }, // 6
+        { pubkey: strategySharesAta, isSigner: false, isWritable: true }, // 7
+        { pubkey: sharesMint, isSigner: false, isWritable: true }, // 8
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 9
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 10
+        { pubkey: constants_1.KLEND_PROGRAM, isSigner: false, isWritable: false }, // 11
+        // WithdrawFromAvailable event CPI (12-13)
+        { pubkey: eventAuthority, isSigner: false, isWritable: false }, // 12
+        { pubkey: constants_1.KAMINO_VAULT_PROGRAM, isSigner: false, isWritable: false }, // 13
+        // WithdrawFromInvested (14-22)
+        { pubkey: vaultState, isSigner: false, isWritable: true }, // 14 (dup)
+        { pubkey: reserveConfig.reserve, isSigner: false, isWritable: true }, // 15
+        { pubkey: reserveConfig.ctokenVault, isSigner: false, isWritable: true }, // 16
+        { pubkey: reserveConfig.lendingMarket, isSigner: false, isWritable: false }, // 17
+        { pubkey: reserveConfig.lendingMarketAuthority, isSigner: false, isWritable: false }, // 18
+        { pubkey: reserveConfig.reserveLiquiditySupply, isSigner: false, isWritable: true }, // 19
+        { pubkey: reserveConfig.reserveCollateralMint, isSigner: false, isWritable: true }, // 20
+        { pubkey: reserveConfig.reserveCollateralTokenProgram, isSigner: false, isWritable: false }, // 21
+        { pubkey: SYSVAR_INSTRUCTIONS, isSigner: false, isWritable: false }, // 22
+        // Withdraw event CPI (23-24)
+        { pubkey: eventAuthority, isSigner: false, isWritable: false }, // 23
+        { pubkey: constants_1.KAMINO_VAULT_PROGRAM, isSigner: false, isWritable: false }, // 24
+    ];
+}
+// ---------------------------------------------------------------------------
+// Kamino kVault Staleness Check
+// ---------------------------------------------------------------------------
+/** Offset of `last_fee_charge_timestamp` (u64) in Kamino VaultState account data */
+const KVAULT_LAST_FEE_CHARGE_TS_OFFSET = 272; // 8 disc + 264
+/** Minimum data length to read `last_fee_charge_timestamp` */
+const KVAULT_MIN_READ_SIZE = KVAULT_LAST_FEE_CHARGE_TS_OFFSET + 8;
+/** Staleness threshold in seconds (matches elemental-lend KVAULT_STALENESS_THRESHOLD) */
+exports.KVAULT_STALENESS_THRESHOLD = 120;
+/**
+ * Read `last_fee_charge_timestamp` from raw Kamino VaultState account data.
+ * Returns undefined if data is too short.
+ */
+function readKvaultLastFeeChargeTs(data) {
+    if (data.length < KVAULT_MIN_READ_SIZE)
+        return undefined;
+    const buf = Buffer.from(data);
+    // Read as u64 LE — timestamp fits in a regular number
+    return Number(buf.readBigUInt64LE(KVAULT_LAST_FEE_CHARGE_TS_OFFSET));
+}
+/**
+ * Check if a Kamino kVault is stale (needs an `invest` call to refresh).
+ *
+ * @param vaultStateData - Raw account data for the Kamino VaultState
+ * @param currentSlotTimestamp - Current cluster timestamp (seconds)
+ * @returns true if the vault is stale (last_fee_charge_timestamp is older than threshold)
+ */
+function isKvaultStale(vaultStateData, currentSlotTimestamp) {
+    const ts = readKvaultLastFeeChargeTs(vaultStateData);
+    if (ts === undefined)
+        return true; // can't read — assume stale
+    return (currentSlotTimestamp - ts) > exports.KVAULT_STALENESS_THRESHOLD;
+}
+/**
+ * Check if any registered kVault protocol is stale and return the stale vault states.
+ *
+ * @param connection - Solana connection
+ * @param protocols - Protocol pubkeys from the lend strategy state
+ * @returns Array of stale kVault state pubkeys
+ */
+async function findStaleKvaults(connection, protocols) {
+    if (protocols.length === 0)
+        return [];
+    const [accountInfos, slot] = await Promise.all([
+        connection.getMultipleAccountsInfo(protocols),
+        connection.getSlot("confirmed"),
+    ]);
+    // Approximate current timestamp via the slot's block time. If the RPC has
+    // no block time available, fall back to wall-clock — close enough for the
+    // 120s staleness check.
+    const blockTime = await connection.getBlockTime(slot);
+    const currentTs = blockTime ?? Math.floor(Date.now() / 1000);
+    const stale = [];
+    for (let i = 0; i < protocols.length; i++) {
+        const info = accountInfos[i];
+        if (!info)
+            continue;
+        // Only check accounts owned by Kamino Vault program
+        if (!info.owner.equals(constants_1.KAMINO_VAULT_PROGRAM))
+            continue;
+        if (isKvaultStale(info.data, currentTs)) {
+            stale.push(protocols[i]);
+        }
+    }
+    return stale;
+}
+// ---------------------------------------------------------------------------
+// Kamino Invest Instruction Builder
+// ---------------------------------------------------------------------------
+/** Anchor discriminator: sha256("global:invest")[..8] */
+const IX_INVEST = Buffer.from([13, 245, 180, 103, 254, 182, 121, 4]);
+/** PDA seed for ctoken_vault: ["ctoken_vault", vault_state, reserve] */
+const CTOKEN_VAULT_SEED = Buffer.from("ctoken_vault");
+/** PDA seed for whitelisted_reserves: ["whitelisted_reserves", reserve] */
+const WHITELISTED_RESERVES_SEED = Buffer.from("whitelisted_reserves");
+/**
+ * Build a Kamino `invest` instruction to refresh a stale kVault.
+ *
+ * `invest` is permissionless — anyone can call it. It refreshes the vault's
+ * `last_fee_charge_timestamp` which is required for elemental-lend's update_aum
+ * staleness check (120s threshold).
+ *
+ * @param payer - Transaction signer (pays for any crank fee, usually 0)
+ * @param payerTokenAccount - Payer's base token ATA (for crank fee)
+ * @param vaultState - Kamino vault_state pubkey
+ * @param baseMint - Base token mint (e.g., USDC)
+ * @param vaultStateData - Raw vault_state account data (for reading allocation)
+ * @param reserveData - Raw KLend reserve account data (for reading lending_market, etc.)
+ * @param allocationIndex - Which vault allocation to invest (default 0)
+ */
+function buildKaminoInvestIx(payer, payerTokenAccount, vaultState, baseMint, vaultStateData, reserveData, allocationIndex = 0) {
+    const alloc = readVaultAllocation(vaultStateData, allocationIndex);
+    const res = readReserveAccounts(reserveData);
+    const [lendingMarketAuthority] = findLendingMarketAuthority(res.lendingMarket);
+    const [tokenVault] = findKvaultTokenVault(vaultState);
+    const [authority] = findKvaultAuthority(vaultState);
+    // ctoken_vault PDA: ["ctoken_vault", vault_state, reserve] under Kamino
+    const [ctokenVault] = web3_js_1.PublicKey.findProgramAddressSync([CTOKEN_VAULT_SEED, vaultState.toBuffer(), alloc.reserve.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+    // reserve_whitelist_entry PDA: ["whitelisted_reserves", reserve] under Kamino (optional)
+    const [reserveWhitelist] = web3_js_1.PublicKey.findProgramAddressSync([WHITELISTED_RESERVES_SEED, alloc.reserve.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true }, // 0: payer
+        { pubkey: payerTokenAccount, isSigner: false, isWritable: true }, // 1: payer_token_account
+        { pubkey: vaultState, isSigner: false, isWritable: true }, // 2: vault_state
+        { pubkey: tokenVault, isSigner: false, isWritable: true }, // 3: token_vault
+        { pubkey: baseMint, isSigner: false, isWritable: true }, // 4: token_mint
+        { pubkey: authority, isSigner: false, isWritable: true }, // 5: base_vault_authority
+        { pubkey: ctokenVault, isSigner: false, isWritable: true }, // 6: ctoken_vault
+        { pubkey: alloc.reserve, isSigner: false, isWritable: true }, // 7: reserve
+        { pubkey: res.lendingMarket, isSigner: false, isWritable: false }, // 8: lending_market
+        { pubkey: lendingMarketAuthority, isSigner: false, isWritable: false }, // 9: lending_market_authority
+        { pubkey: res.reserveLiquiditySupply, isSigner: false, isWritable: true }, // 10: reserve_liquidity_supply
+        { pubkey: res.reserveCollateralMint, isSigner: false, isWritable: true }, // 11: reserve_collateral_mint
+        { pubkey: reserveWhitelist, isSigner: false, isWritable: false }, // 12: reserve_whitelist_entry (optional)
+        { pubkey: constants_1.KLEND_PROGRAM, isSigner: false, isWritable: false }, // 13: klend_program
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 14: reserve_collateral_token_program
+        { pubkey: SPL_TOKEN_PROGRAM, isSigner: false, isWritable: false }, // 15: token_program
+        { pubkey: SYSVAR_INSTRUCTIONS, isSigner: false, isWritable: false }, // 16: instruction_sysvar_account
+    ];
+    // Append ALL reserves for batch refresh, then lending_market at the end.
+    // cpi_refresh_reserves uses .take(reserves_count) to get just reserves.
+    // The lending_market must be in the transaction but AFTER reserves.
+    const allReserves = [];
+    for (let ai = 0; ai < 10; ai++) {
+        try {
+            const a = readVaultAllocation(vaultStateData, ai);
+            if (a.reserve.equals(web3_js_1.PublicKey.default))
+                break;
+            allReserves.push(a.reserve);
+        }
+        catch {
+            break;
+        }
+    }
+    for (const r of allReserves) {
+        keys.push({ pubkey: r, isSigner: false, isWritable: true });
+    }
+    // Lending market after reserves (for CPI resolution, not counted as a reserve)
+    keys.push({ pubkey: res.lendingMarket, isSigner: false, isWritable: false });
+    return new web3_js_1.TransactionInstruction({
+        programId: constants_1.KAMINO_VAULT_PROGRAM,
+        keys,
+        data: IX_INVEST,
+    });
+}
+/**
+ * Build Kamino `invest` instructions for all stale kVaults in a lend strategy.
+ *
+ * Checks each registered protocol for staleness and returns invest instructions
+ * for any that are stale.
+ *
+ * @param connection - Solana connection
+ * @param payer - Transaction signer
+ * @param baseMint - Base token mint
+ * @param protocols - Registered protocol pubkeys from lend strategy state
+ */
+async function buildKaminoInvestIxsIfStale(connection, payer, baseMint, protocols) {
+    const staleVaults = await findStaleKvaults(connection, protocols);
+    if (staleVaults.length === 0)
+        return [];
+    const TOKEN_PROG = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+    const ATA_PROG = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+    // Payer's base ATA (for crank fee — usually 0)
+    const [payerAta] = web3_js_1.PublicKey.findProgramAddressSync([payer.toBuffer(), TOKEN_PROG.toBuffer(), baseMint.toBuffer()], ATA_PROG);
+    // Batch-fetch all vault states in one round-trip, then derive the reserve
+    // pubkeys from the returned buffers, then batch-fetch all reserves. Total:
+    // 2 RPC calls regardless of how many vaults are stale (previous loop did
+    // 2N sequential calls).
+    const vaultInfos = await connection.getMultipleAccountsInfo(staleVaults, "confirmed");
+    const reserveKeys = vaultInfos.map((info) => {
+        if (!info)
+            return null;
+        try {
+            const alloc = readVaultAllocation(info.data, 0);
+            return alloc.reserve.equals(web3_js_1.PublicKey.default) ? null : alloc.reserve;
+        }
+        catch {
+            return null;
+        }
+    });
+    // Reserves to fetch: only the non-null ones, but remember which original
+    // index each corresponds to so we can line them back up.
+    const reserveFetchList = [];
+    const reserveIdx = [];
+    for (let i = 0; i < reserveKeys.length; i++) {
+        const r = reserveKeys[i];
+        if (r) {
+            reserveIdx.push(i);
+            reserveFetchList.push(r);
+        }
+    }
+    const reserveInfos = reserveFetchList.length > 0
+        ? await connection.getMultipleAccountsInfo(reserveFetchList, "confirmed")
+        : [];
+    const ixs = [];
+    for (let j = 0; j < reserveFetchList.length; j++) {
+        const origIdx = reserveIdx[j];
+        const vaultInfo = vaultInfos[origIdx];
+        const reserveInfo = reserveInfos[j];
+        if (!reserveInfo)
+            continue;
+        // Validate reserve is owned by KLend (skip if migrated/closed)
+        if (!reserveInfo.owner.equals(constants_1.KLEND_PROGRAM))
+            continue;
+        try {
+            ixs.push(buildKaminoInvestIx(payer, payerAta, staleVaults[origIdx], baseMint, vaultInfo.data, reserveInfo.data, 0));
+        }
+        catch {
+            // Skip if ix builder can't parse the data
+            continue;
+        }
+    }
+    return ixs;
+}

package/dist/elemental-lend/pda.d.ts

@@ -0,0 +1,12 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function findStrategyStatePda(baseMint: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function findStvPositionPda(stv: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive the per-strategy_state `ManagerRole` PDA for Elemental Lend.
+ * Seeds: `["manager", strategy_state, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account (`p-stv-core`
+ * → STV, `jlpd-strategy` → JlpdConfig).
+ */
+export declare function findLendManagerRolePda(strategyState: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];