@elmntl/jlpd-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,743 @@
+import { PublicKey, AddressLookupTableAccount, Connection, VersionedTransaction, TransactionInstruction } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+
+type PoolName = "SOL" | "USDC" | "JupUSD" | "BTC" | "ETH";
+type JupEarnDirection = "Deposit" | "Withdraw";
+type MoveDirection = "ToVault" | "FromVault";
+type SwapDirection = "JlxToJlp" | "JlpToJlx";
+interface JLPVault {
+    admin: PublicKey;
+    manager: PublicKey;
+    feeReceiver: PublicKey;
+    jlpMint: PublicKey;
+    baseAssetMints: PublicKey[];
+    jlxAssetMints: PublicKey[];
+    oracleStalenessThreshold: BN;
+    flags: number;
+    jlpSlippageBps: number;
+    version: number;
+    bump: number;
+}
+interface STV {
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    jvMint: PublicKey;
+    pps: BN;
+    hwm: BN;
+    lastMgmtFeeTs: BN;
+    baseLoaned: BN;
+    accruedFeesJlx: BN;
+    maxDeposit: BN;
+    minDeposit: BN;
+    mgmtFeeBps: number;
+    perfFeeBps: number;
+    flags: number;
+    version: number;
+    bump: number;
+}
+interface ExchangeRateResult {
+    rate: number;
+    rawRate: bigint;
+    storedRate: number;
+    staleness: number;
+    isFresh: boolean;
+}
+interface JupiterLendPool {
+    mint: PublicKey;
+    name: PoolName;
+    lending: PublicKey;
+    fTokenMint: PublicKey;
+    tokenReservesLiquidity: PublicKey;
+    supplyPositionOnLiquidity: PublicKey;
+    rewardsRateModel: PublicKey;
+    vault: PublicKey;
+    rateModel: PublicKey;
+    claimAccount: PublicKey;
+    decimals: number;
+    stvIndex: number;
+    hasJupiterLend: boolean;
+}
+interface AccountMeta {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+interface SwapQuote {
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    inAmount: BN;
+    outAmount: BN;
+    minOutAmount: BN;
+    priceImpactPct: number;
+    route: string[];
+    jupiterData: Buffer;
+    remainingAccounts: AccountMeta[];
+    addressLookupTables: AddressLookupTableAccount[];
+    computeUnitLimit: number;
+}
+interface LendingAccountData {
+    mint: PublicKey;
+    fTokenMint: PublicKey;
+    lendingId: number;
+    decimals: number;
+    rewardsRateModel: PublicKey;
+    liquidityExchangePrice: bigint;
+    tokenExchangePrice: bigint;
+    lastUpdateTimestamp: bigint;
+    tokenReservesLiquidity: PublicKey;
+    supplyPositionOnLiquidity: PublicKey;
+    bump: number;
+}
+interface RewardsRateModelData {
+    mint: PublicKey;
+    startTvl: bigint;
+    duration: bigint;
+    startTime: bigint;
+    yearlyReward: bigint;
+    nextDuration: bigint;
+    nextRewardAmount: bigint;
+    bump: number;
+}
+interface UpdateVaultParams {
+    jlpMint?: PublicKey | null;
+    baseAssetMints?: PublicKey[] | null;
+    jlxAssetMints?: PublicKey[] | null;
+    newAdmin?: PublicKey | null;
+    manager?: PublicKey;
+    feeReceiver?: PublicKey;
+    oracleStalenessThreshold?: BN | null;
+    jlpSlippageBps?: number;
+    flags?: number;
+}
+interface UpdateStvParams$1 {
+    mgmtFeeBps?: number;
+    perfFeeBps?: number;
+    maxDeposit?: BN;
+    minDeposit?: BN;
+    flags?: number;
+}
+interface InitializeStvParams$1 {
+    poolName: PoolName;
+    mgmtFeeBps: number;
+    perfFeeBps: number;
+    maxDeposit: BN;
+    minDeposit: BN;
+}
+interface JupiterQuoteResponse {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: {
+        amount: string;
+        feeBps: number;
+    } | null;
+    priceImpactPct: string;
+    routePlan: Array<{
+        swapInfo: {
+            ammKey: string;
+            label?: string;
+            inputMint: string;
+            outputMint: string;
+            inAmount: string;
+            outAmount: string;
+            feeAmount: string;
+            feeMint: string;
+        };
+        percent: number;
+    }>;
+    contextSlot?: number;
+    timeTaken?: number;
+}
+interface JupiterSwapInstructionsResponse {
+    tokenLedgerInstruction: SerializedInstruction | null;
+    computeBudgetInstructions: SerializedInstruction[];
+    setupInstructions: SerializedInstruction[];
+    swapInstruction: SerializedInstruction;
+    cleanupInstruction: SerializedInstruction | null;
+    addressLookupTableAddresses: string[];
+    computeUnitLimit?: number;
+    error?: string;
+}
+interface SerializedInstruction {
+    programId: string;
+    accounts: Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+    data: string;
+}
+
+declare class JlpdClientError extends Error {
+    constructor(message: string);
+}
+interface DepositParams {
+    user: PublicKey;
+    amount: BN;
+}
+interface WithdrawParams {
+    user: PublicKey;
+    shares: BN;
+}
+interface JupEarnParams$1 {
+    manager: PublicKey;
+    direction: JupEarnDirection;
+    amount: BN;
+}
+interface MoveJlxParams$1 {
+    manager: PublicKey;
+    direction: MoveDirection;
+    jlxAmount: BN;
+}
+interface ClaimFeesParams {
+    manager: PublicKey;
+}
+interface SwapJlxJlpParams$1 {
+    manager: PublicKey;
+    pool: PoolName;
+    direction: SwapDirection;
+    amountIn: BN;
+    expectedOut: BN;
+    quote: SwapQuote;
+}
+interface SwapJlxJlxParams$1 {
+    manager: PublicKey;
+    fromPool: PoolName;
+    toPool: PoolName;
+    amountIn: BN;
+    minOut: BN;
+    quote: SwapQuote;
+}
+interface SettleYieldParams {
+    manager: PublicKey;
+    /** Manager-provided JLP rate (8 decimals, e.g., 460_000_000 = $4.60)
+     * Use fetchJlpRate() from jupiter/price to get this value */
+    jlpRate: BN;
+}
+/**
+ * Main SDK client for JLP.D program
+ */
+declare class JlpdClient {
+    readonly connection: Connection;
+    readonly programId: PublicKey;
+    readonly vaultPda: PublicKey;
+    readonly vaultBump: number;
+    private readonly poolContextCache;
+    constructor(connection: Connection, programId?: PublicKey);
+    static mainnet(connection: Connection): JlpdClient;
+    static devnet(connection: Connection): JlpdClient;
+    fetchVault(): Promise<JLPVault | null>;
+    fetchStv(baseMint: PublicKey): Promise<STV | null>;
+    fetchExchangeRate(poolName: PoolName): Promise<ExchangeRateResult>;
+    pool(poolNameOrMint: PoolName | PublicKey): PoolContext;
+    swap(): SwapContext;
+    admin(): AdminContext;
+    buildTransaction(payer: PublicKey, ixs: TransactionInstruction[], alts?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
+}
+/**
+ * Context for pool-specific operations
+ */
+declare class PoolContext {
+    readonly client: JlpdClient;
+    readonly pool: JupiterLendPool;
+    readonly stvPda: PublicKey;
+    readonly stvBump: number;
+    readonly vaultStagingAta: PublicKey;
+    readonly vaultJlpAta: PublicKey;
+    readonly stvBaseAta: PublicKey;
+    readonly stvJlxAta: PublicKey;
+    constructor(client: JlpdClient, pool: JupiterLendPool);
+    deposit(params: DepositParams): Promise<VersionedTransaction>;
+    withdraw(params: WithdrawParams): Promise<VersionedTransaction>;
+    jupEarn(params: JupEarnParams$1): Promise<VersionedTransaction>;
+    moveJlx(params: MoveJlxParams$1): Promise<VersionedTransaction>;
+    claimFees(params: ClaimFeesParams): Promise<VersionedTransaction>;
+    updateStv(params: {
+        admin: PublicKey;
+    } & UpdateStvParams$1): Promise<VersionedTransaction>;
+}
+/**
+ * Context for swap operations
+ */
+declare class SwapContext {
+    readonly client: JlpdClient;
+    constructor(client: JlpdClient);
+    quoteJlxJlp(params: {
+        pool: PoolName;
+        direction: SwapDirection;
+        amountIn: BN;
+        slippageBps?: number;
+    }): Promise<SwapQuote>;
+    swapJlxJlp(params: SwapJlxJlpParams$1): Promise<VersionedTransaction>;
+    quoteJlxJlx(params: {
+        fromPool: PoolName;
+        toPool: PoolName;
+        amountIn: BN;
+        slippageBps?: number;
+    }): Promise<SwapQuote>;
+    swapJlxJlx(params: SwapJlxJlxParams$1): Promise<VersionedTransaction>;
+}
+/**
+ * Context for admin operations
+ */
+declare class AdminContext {
+    readonly client: JlpdClient;
+    constructor(client: JlpdClient);
+    initOrUpdateVault(params: {
+        admin: PublicKey;
+    } & UpdateVaultParams): Promise<VersionedTransaction>;
+    initializeStv(params: {
+        admin: PublicKey;
+    } & InitializeStvParams$1, jvMintKeypair: PublicKey): Promise<VersionedTransaction>;
+    settleYield(params: SettleYieldParams): Promise<VersionedTransaction>;
+}
+
+declare const JLPD_PROGRAM_ID: PublicKey;
+declare const JUPITER_LEND_PROGRAM_ID$1: PublicKey;
+declare const JUPITER_SWAP_PROGRAM_ID: PublicKey;
+declare const SEED_JLP_VAULT = "jlp_vault";
+declare const SEED_STV = "stv";
+declare const FLAG_PAUSED = 1;
+declare const FLAG_DEPOSITS_DISABLED = 2;
+declare const FLAG_WITHDRAWALS_DISABLED = 4;
+declare const FLAG_JLP_DISABLED = 8;
+declare const FLAG_REBALANCE_DISABLED = 16;
+declare const PPS_DECIMALS = 1000000000;
+declare const EXCHANGE_RATE_PRECISION = 1000000000000;
+declare const MINTS: {
+    readonly JLP: PublicKey;
+    readonly WSOL: PublicKey;
+    readonly USDC: PublicKey;
+    readonly WBTC: PublicKey;
+    readonly WETH: PublicKey;
+    readonly JupUSD: PublicKey;
+};
+declare enum STV_INDEX {
+    BTC = 0,
+    ETH = 1,
+    SOL = 2,
+    USDC = 3,
+    JupUSD = 4
+}
+declare const ORACLES: {
+    readonly DOVES_BTC_USD: PublicKey;
+    readonly DOVES_ETH_USD: PublicKey;
+    readonly DOVES_SOL_USD: PublicKey;
+    readonly PYTH_JLP_USD: PublicKey;
+};
+
+/**
+ * Derive the JLP Vault PDA address (cached)
+ * Seeds: ["jlp_vault"]
+ */
+declare function deriveVaultPda(programId: PublicKey): [PublicKey, number];
+/**
+ * Derive an STV (Single Token Vault) PDA address (cached)
+ * Seeds: ["stv", base_mint]
+ */
+declare function deriveStvPda(baseMint: PublicKey, programId: PublicKey): [PublicKey, number];
+/**
+ * Clear PDA cache (useful for testing)
+ */
+declare function clearPdaCache(): void;
+
+/**
+ * JLPVault account layout (464 bytes data + 8 byte discriminator = 472 bytes total)
+ */
+declare const JLP_VAULT_DATA_SIZE = 464;
+declare const JLP_VAULT_ACCOUNT_SIZE: number;
+declare const JLP_VAULT_DISCRIMINATOR: Buffer<ArrayBuffer>;
+/**
+ * Parse a JLPVault account from raw account data
+ */
+declare function parseVault(data: Buffer): JLPVault;
+
+/**
+ * STV (Single Token Vault) account layout (160 bytes data + 8 byte discriminator = 168 bytes total)
+ */
+declare const STV_DATA_SIZE = 160;
+declare const STV_ACCOUNT_SIZE: number;
+declare const STV_DISCRIMINATOR: Buffer<ArrayBuffer>;
+/**
+ * Parse an STV account from raw account data
+ */
+declare function parseStv(data: Buffer): STV;
+
+/**
+ * Derive ATA address (cached)
+ */
+declare function deriveAta(mint: PublicKey, owner: PublicKey, allowPda?: boolean): PublicKey;
+/**
+ * Derive all ATAs for a user interacting with an STV (cached)
+ */
+declare function deriveUserAtas(baseMint: PublicKey, jvMint: PublicKey, userWallet: PublicKey): {
+    baseAta: PublicKey;
+    jvxAta: PublicKey;
+};
+/**
+ * Derive all ATAs owned by an STV PDA (cached)
+ */
+declare function deriveStvAtas(baseMint: PublicKey, jlxMint: PublicKey, stvPda: PublicKey): {
+    baseAta: PublicKey;
+    jlxAta: PublicKey;
+};
+/**
+ * Derive vault staging and JLP ATAs (owned by vault PDA, cached)
+ */
+declare function deriveVaultAtas(jlxMint: PublicKey, jlpMint: PublicKey, vaultPda: PublicKey): {
+    stagingAta: PublicKey;
+    jlpAta: PublicKey;
+};
+/**
+ * Clear ATA cache (useful for testing)
+ */
+declare function clearAtaCache(): void;
+
+/**
+ * Calculate NAV for an STV
+ * NAV = stv_base_ata.amount + (stv_jlx_ata.amount * exchange_rate / 1e12) + base_loaned
+ */
+declare function calculateNav(stvBaseBalance: BN, stvJlxBalance: BN, exchangeRate: bigint, baseLoaned: BN): BN;
+/**
+ * Calculate PPS from NAV and total jvX supply
+ * PPS = NAV * PPS_DECIMALS / total_jvx_supply
+ */
+declare function calculatePps(nav: BN, jvSupply: BN): BN;
+/**
+ * Convert shares to base amount
+ */
+declare function sharesToBase(shares: BN, pps: BN): BN;
+/**
+ * Convert base amount to shares
+ */
+declare function baseToShares(base: BN, pps: BN): BN;
+/**
+ * Convert jlX to base using exchange rate
+ */
+declare function jlxToBase(jlxAmount: BN, exchangeRate: BN): BN;
+/**
+ * Convert base to jlX using exchange rate
+ */
+declare function baseToJlx(baseAmount: BN, exchangeRate: BN): BN;
+/**
+ * Calculate full exchange rate including time-accrued rewards
+ */
+declare function calculateExchangeRate(storedRate: bigint, rewardsRate: bigint, currentTimestamp: bigint, lastUpdateTimestamp: bigint, fTokenTotalSupply: bigint): bigint;
+
+declare const LENDING_ADMIN: PublicKey;
+declare const LIQUIDITY_PROGRAM_ID: PublicKey;
+declare const LIQUIDITY_SINGLETON: PublicKey;
+declare const WSOL_POOL: JupiterLendPool;
+declare const USDC_POOL: JupiterLendPool;
+declare const JUPUSD_POOL: JupiterLendPool;
+declare const WBTC_POOL: JupiterLendPool;
+declare const WETH_POOL: JupiterLendPool;
+declare const POOLS: Record<PoolName, JupiterLendPool>;
+declare function getPoolByName(name: PoolName): JupiterLendPool | undefined;
+declare function getPoolByMint(mint: PublicKey): JupiterLendPool | undefined;
+
+declare const JUPITER_LEND_PROGRAM_ID: PublicKey;
+/**
+ * Build remaining accounts for deposit/withdraw exchange rate lookup
+ */
+declare function buildExchangeRateAccounts(pool: JupiterLendPool): {
+    lending: PublicKey;
+    rewardsRateModel: PublicKey;
+} | null;
+/**
+ * Build remaining accounts for jup_earn_deposit instruction (17 accounts + program ID)
+ */
+declare function buildJupEarnDepositAccounts(pool: JupiterLendPool, stvPda: PublicKey, stvBaseAta: PublicKey, stvJlxAta: PublicKey): AccountMeta[];
+/**
+ * Build remaining accounts for jup_earn_withdraw instruction (18 accounts + program ID)
+ */
+declare function buildJupEarnWithdrawAccounts(pool: JupiterLendPool, stvPda: PublicKey, stvJlxAta: PublicKey, stvBaseAta: PublicKey): AccountMeta[];
+/**
+ * Parse Lending account data from buffer
+ */
+declare function parseLendingAccount(data: Buffer): LendingAccountData;
+/**
+ * Parse LendingRewardsRateModel account data from buffer
+ */
+declare function parseRewardsRateModel(data: Buffer): RewardsRateModelData;
+
+/**
+ * Get a swap quote from Jupiter API
+ */
+declare function getJupiterQuote(inputMint: PublicKey, outputMint: PublicKey, amount: bigint | number, slippageBps?: number, maxAccounts?: number): Promise<JupiterQuoteResponse>;
+/**
+ * Get swap instructions from Jupiter API
+ */
+declare function getJupiterSwapInstructions(quote: JupiterQuoteResponse, userPubkey: PublicKey): Promise<JupiterSwapInstructionsResponse>;
+/**
+ * Parse swap instruction to extract remaining accounts
+ */
+declare function parseSwapRemainingAccounts(swapInstruction: SerializedInstruction): AccountMeta[];
+/**
+ * Fetch Address Lookup Tables from the chain
+ */
+declare function fetchAddressLookupTables(connection: Connection, addresses: string[]): Promise<AddressLookupTableAccount[]>;
+/**
+ * Build complete swap data for CPI including quote, instructions, and ALTs
+ */
+declare function buildSwapData(connection: Connection, inputMint: PublicKey, outputMint: PublicKey, amount: bigint | number, userPubkey: PublicKey, slippageBps?: number, maxAccounts?: number): Promise<{
+    quote: JupiterQuoteResponse;
+    instructions: JupiterSwapInstructionsResponse;
+    remainingAccounts: AccountMeta[];
+    addressLookupTables: AddressLookupTableAccount[];
+}>;
+
+/**
+ * Jupiter Price API V3 Integration
+ *
+ * Used to fetch token prices for settle_yield instruction.
+ * Manager must provide JLP rate which is validated against Pyth on-chain.
+ */
+
+/**
+ * Jupiter Price API V3 response for a single token
+ */
+interface JupiterPriceData {
+    createdAt: string;
+    liquidity: number;
+    usdPrice: number;
+    blockId: number;
+    decimals: number;
+    priceChange24h: number;
+}
+/**
+ * Jupiter Price API V3 response
+ */
+type JupiterPriceResponse = {
+    [mint: string]: JupiterPriceData;
+};
+/**
+ * Fetch token price from Jupiter Price API V3
+ *
+ * @param mint Token mint address
+ * @param apiKey Jupiter API key (uses default if not provided)
+ * @returns Price in USD as a number, or null if unavailable
+ */
+declare function fetchJupiterPriceUsd(mint: string, apiKey?: string): Promise<number | null>;
+/**
+ * Fetch JLP price and convert to 8 decimals for on-chain use
+ *
+ * This is the format required by the settle_yield instruction's jlp_rate parameter.
+ * The rate is validated against Pyth oracle on-chain (must be within 50 bps).
+ *
+ * @param jlpMint JLP token mint address
+ * @param fallbackPrice Fallback price in USD if API fails (default: $4.60)
+ * @param apiKey Jupiter API key (uses default if not provided)
+ * @returns Price as BN with 8 decimals (e.g., $4.60 -> 460_000_000)
+ *
+ * @example
+ * ```typescript
+ * const jlpRate = await fetchJlpRate(MINTS.JLP);
+ * const tx = await adminContext.settleYield({
+ *   manager: wallet.publicKey,
+ *   jlpRate,
+ *   oracles: { ... }
+ * });
+ * ```
+ */
+declare function fetchJlpRate(jlpMint: string, fallbackPrice?: number, apiKey?: string): Promise<BN>;
+
+interface InitOrUpdateJlpVaultParams {
+    jlpMint: PublicKey | null;
+    baseAssetMints: PublicKey[] | null;
+    jlxAssetMints: PublicKey[] | null;
+    newAdmin: PublicKey | null;
+    manager?: PublicKey;
+    feeReceiver?: PublicKey;
+    flags?: number;
+    jlpSlippageBps?: number;
+    oracleStalenessThreshold: BN | null;
+}
+interface InitializeStvParams {
+    mgmtFeeBps: number;
+    perfFeeBps: number;
+    maxDeposit: BN;
+    minDeposit: BN;
+}
+interface UpdateStvParams {
+    mgmtFeeBps?: number;
+    perfFeeBps?: number;
+    flags?: number;
+    maxDeposit?: BN;
+    minDeposit?: BN;
+}
+interface InitOrUpdateJlpVaultAccounts {
+    admin: PublicKey;
+    jlpVault: PublicKey;
+    systemProgram: PublicKey;
+}
+interface InitializeStvAccounts {
+    admin: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    jvMint: PublicKey;
+    stvJlxAta: PublicKey;
+    systemProgram: PublicKey;
+    tokenProgram: PublicKey;
+    associatedTokenProgram: PublicKey;
+    rent: PublicKey;
+}
+interface UpdateStvAccounts {
+    admin: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+}
+declare function createInitOrUpdateVaultInstruction(params: InitOrUpdateJlpVaultParams, accounts: InitOrUpdateJlpVaultAccounts, programId?: PublicKey): TransactionInstruction;
+declare function createInitializeStvInstruction(params: InitializeStvParams, accounts: InitializeStvAccounts, programId?: PublicKey): TransactionInstruction;
+declare function createUpdateStvInstruction(params: UpdateStvParams, accounts: UpdateStvAccounts, programId?: PublicKey): TransactionInstruction;
+
+interface DepositAccounts {
+    user: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    jvMint: PublicKey;
+    userBaseAta: PublicKey;
+    userJvxAta: PublicKey;
+    stvBaseAta: PublicKey;
+    stvJlxAta: PublicKey;
+    tokenProgram: PublicKey;
+}
+interface WithdrawAccounts {
+    user: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    jvMint: PublicKey;
+    userBaseAta: PublicKey;
+    userJvxAta: PublicKey;
+    stvBaseAta: PublicKey;
+    stvJlxAta: PublicKey;
+    tokenProgram: PublicKey;
+}
+/**
+ * Create a deposit instruction
+ */
+declare function createDepositInstruction(amount: BN, accounts: DepositAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+/**
+ * Create a withdraw instruction
+ */
+declare function createWithdrawInstruction(sharesToBurn: BN, accounts: WithdrawAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+
+interface JupEarnParams {
+    direction: JupEarnDirection;
+    amount: BN;
+}
+interface MoveJlxParams {
+    amountJlx: BN;
+    direction: MoveDirection;
+}
+interface SwapJlxJlxParams {
+    fromIndex: number;
+    toIndex: number;
+    amountIn: BN;
+    minOut: BN;
+    jupiterData: Buffer;
+}
+interface SwapJlxJlpParams {
+    stvIndex: number;
+    direction: SwapDirection;
+    amountIn: BN;
+    expectedAmountOut: BN;
+    jupiterData: Buffer;
+}
+interface JupEarnAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    stvBaseAta: PublicKey;
+    stvJlxAta: PublicKey;
+    tokenProgram: PublicKey;
+}
+interface MoveStvAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    stvJlxAta: PublicKey;
+    vaultStagingAta: PublicKey;
+    tokenProgram: PublicKey;
+}
+interface SwapJlxJlxAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    fromJlxMint: PublicKey;
+    toJlxMint: PublicKey;
+    fromJlxAta: PublicKey;
+    toJlxAta: PublicKey;
+    tokenProgram: PublicKey;
+    jupiterProgram: PublicKey;
+}
+interface SwapJlxJlpAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    vaultJlxAta: PublicKey;
+    vaultJlpAta: PublicKey;
+    jlpMint: PublicKey;
+    tokenProgram: PublicKey;
+    jupiterProgram: PublicKey;
+}
+interface SettleYieldAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    vaultJlpAta: PublicKey;
+    jlpMint: PublicKey;
+    stvBtc: PublicKey;
+    stvEth: PublicKey;
+    stvSol: PublicKey;
+    stvUsdc: PublicKey;
+    stvJupusd: PublicKey;
+    stagingBtc: PublicKey;
+    stagingEth: PublicKey;
+    stagingSol: PublicKey;
+    stagingUsdc: PublicKey;
+    stagingJupusd: PublicKey;
+    oracleBtc: PublicKey;
+    oracleEth: PublicKey;
+    oracleSol: PublicKey;
+    oracleJlp: PublicKey;
+}
+interface SettleYieldInstructionParams {
+    /** Manager-provided JLP rate (8 decimals, e.g., 460_000_000 = $4.60) */
+    jlpRate: BN;
+}
+declare function createJupEarnInstruction(params: JupEarnParams, accounts: JupEarnAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+declare function createMoveJlxInstruction(params: MoveJlxParams, accounts: MoveStvAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+declare function createSwapJlxJlxInstruction(params: SwapJlxJlxParams, accounts: SwapJlxJlxAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+declare function createSwapJlxJlpInstruction(params: SwapJlxJlpParams, accounts: SwapJlxJlpAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+declare function createSettleYieldInstruction(params: SettleYieldInstructionParams, accounts: SettleYieldAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+
+interface ClaimFeesAccounts {
+    manager: PublicKey;
+    jlpVault: PublicKey;
+    stv: PublicKey;
+    baseMint: PublicKey;
+    jlMint: PublicKey;
+    jvMint: PublicKey;
+    stvBaseAta: PublicKey;
+    stvJlxAta: PublicKey;
+    feeReceiverJlxAta: PublicKey;
+    tokenProgram: PublicKey;
+}
+/**
+ * Create a claim_fees instruction
+ */
+declare function createClaimFeesInstruction(accounts: ClaimFeesAccounts, remainingAccounts?: AccountMeta[], programId?: PublicKey): TransactionInstruction;
+
+export { type AccountMeta, AdminContext, type ClaimFeesAccounts, type ClaimFeesParams, type DepositAccounts, type DepositParams, EXCHANGE_RATE_PRECISION, type ExchangeRateResult, FLAG_DEPOSITS_DISABLED, FLAG_JLP_DISABLED, FLAG_PAUSED, FLAG_REBALANCE_DISABLED, FLAG_WITHDRAWALS_DISABLED, type InitOrUpdateJlpVaultAccounts, type InitOrUpdateJlpVaultParams, type InitializeStvAccounts, type InitializeStvParams$1 as InitializeStvParams, JLPD_PROGRAM_ID, type JLPVault, JLP_VAULT_ACCOUNT_SIZE, JLP_VAULT_DATA_SIZE, JLP_VAULT_DISCRIMINATOR, JUPITER_LEND_PROGRAM_ID$1 as JUPITER_LEND_PROGRAM_ID, JUPITER_SWAP_PROGRAM_ID, JUPUSD_POOL, JUPITER_LEND_PROGRAM_ID as JUP_LEND_PROGRAM_ID, JlpdClient, JlpdClientError, type JupEarnAccounts, type JupEarnDirection, type JupEarnParams$1 as JupEarnParams, type JupiterLendPool, type JupiterPriceData, type JupiterPriceResponse, type JupiterQuoteResponse, type JupiterSwapInstructionsResponse, LENDING_ADMIN, LIQUIDITY_PROGRAM_ID, LIQUIDITY_SINGLETON, type LendingAccountData, MINTS, type MoveDirection, type MoveJlxParams$1 as MoveJlxParams, type MoveStvAccounts, ORACLES, POOLS, PPS_DECIMALS, PoolContext, type PoolName, type RewardsRateModelData, SEED_JLP_VAULT, SEED_STV, type STV, STV_ACCOUNT_SIZE, STV_DATA_SIZE, STV_DISCRIMINATOR, STV_INDEX, type SerializedInstruction, type SettleYieldAccounts, type SettleYieldInstructionParams, type SettleYieldParams, SwapContext, type SwapDirection, type SwapJlxJlpAccounts, type SwapJlxJlpParams$1 as SwapJlxJlpParams, type SwapJlxJlxAccounts, type SwapJlxJlxParams$1 as SwapJlxJlxParams, type SwapQuote, USDC_POOL, type UpdateStvAccounts, type UpdateStvParams$1 as UpdateStvParams, type UpdateVaultParams, WBTC_POOL, WETH_POOL, WSOL_POOL, type WithdrawAccounts, type WithdrawParams, baseToJlx, baseToShares, buildExchangeRateAccounts, buildJupEarnDepositAccounts, buildJupEarnWithdrawAccounts, buildSwapData, calculateExchangeRate, calculateNav, calculatePps, clearAtaCache, clearPdaCache, createClaimFeesInstruction, createDepositInstruction, createInitOrUpdateVaultInstruction, createInitializeStvInstruction, createJupEarnInstruction, createMoveJlxInstruction, createSettleYieldInstruction, createSwapJlxJlpInstruction, createSwapJlxJlxInstruction, createUpdateStvInstruction, createWithdrawInstruction, deriveAta, deriveStvAtas, deriveStvPda, deriveUserAtas, deriveVaultAtas, deriveVaultPda, fetchAddressLookupTables, fetchJlpRate, fetchJupiterPriceUsd, getJupiterQuote, getJupiterSwapInstructions, getPoolByMint, getPoolByName, jlxToBase, parseLendingAccount, parseRewardsRateModel, parseStv, parseSwapRemainingAccounts, parseVault, sharesToBase };