@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/index.js

@@ -1,4458 +1,41 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AdminContext: () => AdminContext,
-  EXCHANGE_RATE_PRECISION: () => EXCHANGE_RATE_PRECISION,
-  FLAG_DEPOSITS_DISABLED: () => FLAG_DEPOSITS_DISABLED,
-  FLAG_JLP_DISABLED: () => FLAG_JLP_DISABLED,
-  FLAG_PAUSED: () => FLAG_PAUSED,
-  FLAG_REBALANCE_DISABLED: () => FLAG_REBALANCE_DISABLED,
-  FLAG_WITHDRAWALS_DISABLED: () => FLAG_WITHDRAWALS_DISABLED,
-  JLPD_PROGRAM_ID: () => JLPD_PROGRAM_ID,
-  JLP_POOL_PUBKEY: () => JLP_POOL_PUBKEY,
-  JLP_VAULT_ACCOUNT_SIZE: () => JLP_VAULT_ACCOUNT_SIZE,
-  JLP_VAULT_DATA_SIZE: () => JLP_VAULT_DATA_SIZE,
-  JLP_VAULT_DISCRIMINATOR: () => JLP_VAULT_DISCRIMINATOR,
-  JUPITER_LEND_PROGRAM_ID: () => JUPITER_LEND_PROGRAM_ID,
-  JUPITER_PERPS_PROGRAM_ID: () => JUPITER_PERPS_PROGRAM_ID,
-  JUPITER_SWAP_PROGRAM_ID: () => JUPITER_SWAP_PROGRAM_ID,
-  JUPUSD_POOL: () => JUPUSD_POOL,
-  JUP_LEND_PROGRAM_ID: () => JUPITER_LEND_PROGRAM_ID2,
-  JlpdClient: () => JlpdClient,
-  JlpdClientError: () => JlpdClientError,
-  LENDING_ADMIN: () => LENDING_ADMIN,
-  LIQUIDITY_PROGRAM_ID: () => LIQUIDITY_PROGRAM_ID,
-  LIQUIDITY_SINGLETON: () => LIQUIDITY_SINGLETON,
-  MINTS: () => MINTS,
-  ORACLES: () => ORACLES,
-  POOLS: () => POOLS,
-  PPS_DECIMALS: () => PPS_DECIMALS,
-  PoolContext: () => PoolContext,
-  SEED_JLP_VAULT: () => SEED_JLP_VAULT,
-  SEED_STV: () => SEED_STV,
-  STV_ACCOUNT_SIZE: () => STV_ACCOUNT_SIZE,
-  STV_DATA_SIZE: () => STV_DATA_SIZE,
-  STV_DISCRIMINATOR: () => STV_DISCRIMINATOR,
-  STV_INDEX: () => STV_INDEX,
-  SwapContext: () => SwapContext,
-  USDC_POOL: () => USDC_POOL,
-  WBTC_POOL: () => WBTC_POOL,
-  WETH_POOL: () => WETH_POOL,
-  WSOL_POOL: () => WSOL_POOL,
-  baseToJlx: () => baseToJlx,
-  baseToShares: () => baseToShares,
-  buildExchangeRateAccounts: () => buildExchangeRateAccounts,
-  buildJupEarnDepositAccounts: () => buildJupEarnDepositAccounts,
-  buildJupEarnWithdrawAccounts: () => buildJupEarnWithdrawAccounts,
-  buildSwapData: () => buildSwapData,
-  calculateExchangeRate: () => calculateExchangeRate,
-  calculateNav: () => calculateNav,
-  calculatePps: () => calculatePps,
-  clearAtaCache: () => clearAtaCache,
-  clearPdaCache: () => clearPdaCache,
-  createClaimFeesInstruction: () => createClaimFeesInstruction,
-  createDepositInstruction: () => createDepositInstruction,
-  createInitOrUpdateVaultInstruction: () => createInitOrUpdateVaultInstruction,
-  createInitializeStvInstruction: () => createInitializeStvInstruction,
-  createJupEarnInstruction: () => createJupEarnInstruction,
-  createMoveJlxInstruction: () => createMoveJlxInstruction,
-  createProgram: () => createProgram,
-  createSettleYieldInstruction: () => createSettleYieldInstruction,
-  createSwapJlxJlpInstruction: () => createSwapJlxJlpInstruction,
-  createUpdateStvInstruction: () => createUpdateStvInstruction,
-  createWithdrawInstruction: () => createWithdrawInstruction,
-  deriveAta: () => deriveAta,
-  deriveStvAtas: () => deriveStvAtas,
-  deriveStvPda: () => deriveStvPda,
-  deriveUserAtas: () => deriveUserAtas,
-  deriveVaultAtas: () => deriveVaultAtas,
-  deriveVaultPda: () => deriveVaultPda,
-  fetchAddressLookupTables: () => fetchAddressLookupTables,
-  fetchJlpRate: () => fetchJlpRate,
-  fetchJupiterPriceUsd: () => fetchJupiterPriceUsd,
-  getJupiterQuote: () => getJupiterQuote,
-  getJupiterSwapInstructions: () => getJupiterSwapInstructions,
-  getPoolByMint: () => getPoolByMint,
-  getPoolByName: () => getPoolByName,
-  jlxToBase: () => jlxToBase,
-  parseLendingAccount: () => parseLendingAccount,
-  parseRewardsRateModel: () => parseRewardsRateModel,
-  parseStv: () => parseStv,
-  parseSwapRemainingAccounts: () => parseSwapRemainingAccounts,
-  parseVault: () => parseVault,
-  sharesToBase: () => sharesToBase
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-module.exports = __toCommonJS(index_exports);
-
-// src/client.ts
-var import_web39 = require("@solana/web3.js");
-var import_anchor6 = require("@coral-xyz/anchor");
-var import_spl_token5 = require("@solana/spl-token");
-
-// src/program.ts
-var import_anchor = require("@coral-xyz/anchor");
-var import_web3 = require("@solana/web3.js");
-
-// idl/jlp_d_program.json
-var jlp_d_program_default = {
-  address: "ELEM2bAobpZNuysfhyF28XGVjA1aTUwm6rPYyv1JX3oq",
-  metadata: {
-    name: "jlp_d_program",
-    version: "0.1.0",
-    spec: "0.1.0",
-    description: "Created with Anchor"
-  },
-  instructions: [
-    {
-      name: "claim_fees",
-      discriminator: [
-        82,
-        251,
-        233,
-        156,
-        12,
-        52,
-        184,
-        202
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager claiming fees on behalf of fee_receiver"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (Jupiter Lend token) - for decimals in transfer_checked"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint (vault share token) - for supply reading in crystallization"
-          ]
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (for NAV calculation)"
-          ]
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (source for fee transfer)"
-          ],
-          writable: true
-        },
-        {
-          name: "fee_receiver_jlx_ata",
-          docs: [
-            "Fee receiver's jlX ATA (destination for fees)"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: []
-    },
-    {
-      name: "close_stv",
-      docs: [
-        "Close an STV account and return rent to admin",
-        "Destructive operation - use only for cleanup/migration",
-        "",
-        "# Safety Checks",
-        "- Validates jvX supply is 0 (no active shares)",
-        "- Validates base_loaned is 0 (no outstanding loans)",
-        "- Validates accrued_fees_jlx is 0 (no unclaimed fees)"
-      ],
-      discriminator: [
-        173,
-        189,
-        151,
-        131,
-        240,
-        39,
-        199,
-        147
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin must sign - verified via vault.has_one = admin"
-          ],
-          writable: true,
-          signer: true,
-          relations: [
-            "jlp_vault"
-          ]
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "JLP Vault for admin validation"
-          ],
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  106,
-                  108,
-                  112,
-                  95,
-                  118,
-                  97,
-                  117,
-                  108,
-                  116
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "stv",
-          docs: [
-            "STV to close"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  115,
-                  116,
-                  118
-                ]
-              },
-              {
-                kind: "account",
-                path: "base_mint"
-              }
-            ]
-          }
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint for this STV - used to verify no active shares"
-          ]
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint for this STV"
-          ]
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: []
-    },
-    {
-      name: "deposit",
-      docs: [
-        "Deposit base asset into the STV and receive jvX shares",
-        "",
-        "# Flow",
-        "1. Crystallize fees inline (ensures fair PPS)",
-        "2. Transfer base asset from user to STV's base ATA",
-        "3. Mint jvX shares to user at post-fee PPS",
-        "",
-        "# Note",
-        "For pools with Jupiter Earn support (SOL, USDC), manager can later convert",
-        "base to jlX via jup_earn_deposit_withdraw instruction.",
-        "For pools without Jupiter Earn (BTC, ETH), base stays in STV's base ATA.",
-        "",
-        "Remaining accounts (optional, for exchange rate):",
-        "[0] = Jupiter Lend lending account",
-        "[1] = Jupiter Lend rewards rate model"
-      ],
-      discriminator: [
-        242,
-        35,
-        198,
-        137,
-        82,
-        225,
-        242,
-        182
-      ],
-      accounts: [
-        {
-          name: "user",
-          docs: [
-            "User performing the deposit"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: bump verified in handler after load() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: uses base_mint account for seeds; bump verified in handler"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (underlying token: SOL, BTC, ETH, USDC)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (Jupiter Lend token) - used for exchange rate reading"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint (vault share token) - STV is mint authority",
-            "Verified against STV.jv_mint in handler"
-          ],
-          writable: true
-        },
-        {
-          name: "user_base_ata",
-          docs: [
-            "User's base asset token account (source for deposit)"
-          ],
-          writable: true
-        },
-        {
-          name: "user_jvx_ata",
-          docs: [
-            "User's jvX token account (destination for shares)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (destination for user's base tokens)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (used for NAV calculation)"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
-    },
-    {
-      name: "init_or_update_jlp_vault",
-      docs: [
-        "Initialize or update the global JLP Vault",
-        "Init: Creates vault PDA with admin, jlp_mint, base_asset_mints (immutable after init)",
-        "Update: Modifies manager, fee_receiver, and rebalance parameters",
-        "Note: ATAs are created externally via script"
-      ],
-      discriminator: [
-        234,
-        24,
-        218,
-        120,
-        213,
-        149,
-        245,
-        213
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin who controls the vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account (zero-copy)",
-            "Uses init_if_needed to support both init and update paths"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  106,
-                  108,
-                  112,
-                  95,
-                  118,
-                  97,
-                  117,
-                  108,
-                  116
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "system_program",
-          docs: [
-            "System program"
-          ],
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "InitOrUpdateJlpVaultParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "initialize_stv",
-      docs: [
-        "Initialize a Single Token Vault (STV) for a specific asset",
-        "Creates the STV PDA, jvX mint (with STV as authority), and jlX ATA"
-      ],
-      discriminator: [
-        136,
-        8,
-        178,
-        176,
-        57,
-        33,
-        1,
-        106
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin of the JLP Vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and admin verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account (zero-copy)"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  115,
-                  116,
-                  118
-                ]
-              },
-              {
-                kind: "account",
-                path: "base_mint"
-              }
-            ]
-          }
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (BTC, ETH, SOL, or USDC)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "Jupiter Lend token mint for this asset"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "Vault share token mint (jvX) - STV is the mint authority",
-            "Client generates keypair and passes it as signer"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (holds Jupiter Lend tokens)",
-            "Uses init_if_needed in case ATA exists from a previous STV initialization"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "account",
-                path: "stv"
-              },
-              {
-                kind: "const",
-                value: [
-                  6,
-                  221,
-                  246,
-                  225,
-                  215,
-                  101,
-                  161,
-                  147,
-                  217,
-                  203,
-                  225,
-                  70,
-                  206,
-                  235,
-                  121,
-                  172,
-                  28,
-                  180,
-                  133,
-                  237,
-                  95,
-                  91,
-                  55,
-                  145,
-                  58,
-                  140,
-                  245,
-                  133,
-                  126,
-                  255,
-                  0,
-                  169
-                ]
-              },
-              {
-                kind: "account",
-                path: "jl_mint"
-              }
-            ],
-            program: {
-              kind: "const",
-              value: [
-                140,
-                151,
-                37,
-                143,
-                78,
-                36,
-                137,
-                241,
-                187,
-                61,
-                16,
-                41,
-                20,
-                142,
-                13,
-                131,
-                11,
-                90,
-                19,
-                153,
-                218,
-                255,
-                16,
-                132,
-                4,
-                142,
-                123,
-                216,
-                219,
-                233,
-                248,
-                89
-              ]
-            }
-          }
-        },
-        {
-          name: "system_program",
-          docs: [
-            "System program"
-          ],
-          address: "11111111111111111111111111111111"
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        },
-        {
-          name: "associated_token_program",
-          docs: [
-            "Associated token program"
-          ],
-          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
-        },
-        {
-          name: "rent",
-          docs: [
-            "Rent sysvar"
-          ],
-          address: "SysvarRent111111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "InitializeStvParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "jup_earn_deposit_withdraw",
-      docs: [
-        "Deposit base to or withdraw from Jupiter Earn",
-        "",
-        "Manager-only operation to convert between base asset and jlX tokens",
-        "via Jupiter Lend. This is used for pools that support Jupiter Earn",
-        "(SOL, USDC) to earn yield on idle funds.",
-        "",
-        "# Directions",
-        "- Deposit: Convert base asset -> jlX (earn Jupiter Earn yield)",
-        "- Withdraw: Convert jlX -> base asset (provide withdrawal liquidity)",
-        "",
-        "# Use Cases",
-        "- After user deposits, manager can deposit base to Jupiter Earn",
-        "- Before user withdrawals, manager can withdraw from Jupiter Earn",
-        "- BTC/ETH pools cannot use Jupiter Earn (not supported)",
-        "",
-        "# Remaining Accounts",
-        "- Deposit: 17 Jupiter Lend accounts (see jup_lend::deposit_accounts)",
-        "- Withdraw: 18 Jupiter Lend accounts (see jup_lend::withdraw_accounts)"
-      ],
-      discriminator: [
-        124,
-        60,
-        71,
-        122,
-        162,
-        212,
-        164,
-        191
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the operation"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: PDA verified in handler"
-          ]
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program - used to validate ATA ownership"
-          ],
-          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "JupEarnParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "move_stv_to_from_vault",
-      docs: [
-        "Move jlX tokens between STV and JLPVault staging ATA",
-        "Direction::ToVault: STV jlX ATA -> Vault staging ATA (preparation for swap)",
-        "Direction::FromVault: Vault staging ATA -> STV jlX ATA (return after swap/unwind)",
-        "",
-        "Remaining accounts (optional, for pools with Jupiter Earn):",
-        "[0] = Jupiter Lend lending account (for exchange rate)",
-        "[1] = Jupiter Lend rewards rate model (for exchange rate)",
-        "",
-        "For base-only pools (BTC, ETH where jl_mint == base_mint):",
-        "No remaining accounts needed - uses 1.0 exchange rate"
-      ],
-      discriminator: [
-        60,
-        104,
-        8,
-        126,
-        254,
-        244,
-        95,
-        221
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the operation"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account (mutable to update base_loaned)",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (for detection of base-only pools)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (for decimals in transfer_checked)",
-            "For base-only pools (BTC, ETH), jl_mint == base_mint"
-          ]
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA",
-            "For base-only pools, this is the base ATA (jl_mint == base_mint)"
-          ],
-          writable: true
-        },
-        {
-          name: "vault_staging_ata",
-          docs: [
-            "Vault's staging jlX ATA (for this specific jl_mint)",
-            "For base-only pools, this is the staging base ATA"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "MoveJlxParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "settle_yield",
-      docs: [
-        "Settle yield/loss from JLP positions across all STVs",
-        "Called periodically (~8 hours) to update all STV values based on JLP performance",
-        "",
-        "# USD-Based Settlement",
-        "1. Values total vault holdings (JLP + staging jlX) in USD using oracles",
-        "2. Values total base_loaned across all STVs in USD",
-        "3. Distributes surplus (yield) or deficit (bad debt) proportionally",
-        "",
-        "# Security",
-        "- BTC/ETH/SOL prices come from Doves oracles (manipulation-resistant)",
-        "- JLP price computed directly from Jupiter Perps Pool account (aumUsd / jlp_supply)",
-        "- Exchange rates come from Jupiter Earn (audited, TWAP-based)",
-        "- Distribution is proportional to each STV's share of total loans",
-        "",
-        "# Accounts",
-        "Requires all 5 STVs, 5 staging jlX ATAs, 3 Doves oracles (BTC/ETH/SOL),",
-        "Jupiter Perps Pool account, JLP mint account",
-        "",
-        "# Remaining Accounts (15 accounts)",
-        "For exchange rate calculation with time-accrued rewards:",
-        "- [0-4]: Jupiter Lend lending accounts (BTC, ETH, SOL, USDC, JupUSD)",
-        "- [5-9]: Jupiter Lend rewards rate model accounts (BTC, ETH, SOL, USDC, JupUSD)",
-        "- [10-14]: jlX mint accounts (jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD)"
-      ],
-      discriminator: [
-        64,
-        28,
-        44,
-        24,
-        43,
-        204,
-        58,
-        215
-      ],
-      accounts: [
-        {
-          name: "jlp_vault",
-          writable: true
-        },
-        {
-          name: "vault_jlp_ata",
-          docs: [
-            "JLP token account owned by vault"
-          ]
-        },
-        {
-          name: "stv_0",
-          writable: true
-        },
-        {
-          name: "stv_1",
-          writable: true
-        },
-        {
-          name: "stv_2",
-          writable: true
-        },
-        {
-          name: "stv_3",
-          writable: true
-        },
-        {
-          name: "stv_4",
-          writable: true
-        },
-        {
-          name: "staging_jlx_0"
-        },
-        {
-          name: "staging_jlx_1"
-        },
-        {
-          name: "staging_jlx_2"
-        },
-        {
-          name: "staging_jlx_3"
-        },
-        {
-          name: "staging_jlx_4"
-        },
-        {
-          name: "doves_btc_usd"
-        },
-        {
-          name: "doves_eth_usd"
-        },
-        {
-          name: "doves_sol_usd"
-        },
-        {
-          name: "jlp_pool"
-        },
-        {
-          name: "jlp_mint_account"
-        },
-        {
-          name: "manager",
-          docs: [
-            "Manager who can perform rebalance operations (verified in handler)"
-          ],
-          signer: true
-        }
-      ],
-      args: []
-    },
-    {
-      name: "swap_jlx_to_from_jlp",
-      docs: [
-        "Swap between different jlX types (e.g., jlSOL -> jlUSDC) via Jupiter",
-        "Manager-only operation for rebalancing vault composition",
-        "",
-        "Remaining accounts: Jupiter swap accounts from API (varies based on route)",
-        "Swap between jlX and JLP tokens via Jupiter",
-        "JlxToJlp: Swap jlX -> JLP (increase vault JLP balance)",
-        "JlpToJlx: Swap JLP -> jlX (decrease vault JLP balance)",
-        "Manager-only operation for JLP position management",
-        "",
-        "Note: JLP positions are tracked via STV.base_loaned and settled",
-        "using settle_yield with Doves oracle prices (USD-based settlement).",
-        "",
-        "Remaining accounts: Jupiter swap accounts from API (varies based on route)"
-      ],
-      discriminator: [
-        229,
-        185,
-        136,
-        170,
-        210,
-        189,
-        172,
-        241
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the swap"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "vault_jlx_ata",
-          docs: [
-            "Vault's staging jlX ATA (source for JlxToJlp, dest for JlpToJlx)",
-            "This is the jlX token that corresponds to stv_index"
-          ],
-          writable: true
-        },
-        {
-          name: "vault_jlp_ata",
-          docs: [
-            "Vault's JLP ATA (dest for JlxToJlp, source for JlpToJlx)"
-          ],
-          writable: true
-        },
-        {
-          name: "jlp_mint",
-          docs: [
-            "JLP mint"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        },
-        {
-          name: "jupiter_program",
-          docs: [
-            "Jupiter aggregator program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "SwapJlxJlpParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "update_stv",
-      docs: [
-        "Update STV parameters including fees and flags",
-        "Admin-only operation to modify STV configuration"
-      ],
-      discriminator: [
-        72,
-        173,
-        200,
-        203,
-        74,
-        83,
-        242,
-        43
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin of the JLP Vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and admin verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account to update",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "UpdateStvParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "withdraw",
-      docs: [
-        "Withdraw base asset by burning jvX shares",
-        "",
-        "# Flow",
-        "1. Crystallize fees inline (ensures fair PPS)",
-        "2. Calculate base amount from shares at post-fee PPS",
-        "3. Burn jvX shares from user",
-        "4. Transfer base from STV's base ATA to user",
-        "",
-        "# Note",
-        "Requires sufficient base balance in STV's base ATA.",
-        "Manager must ensure liquidity by converting jlX to base via",
-        "jup_earn_deposit_withdraw instruction before user withdrawals.",
-        "",
-        "Remaining accounts (optional, for exchange rate):",
-        "[0] = Jupiter Lend lending account",
-        "[1] = Jupiter Lend rewards rate model"
-      ],
-      discriminator: [
-        183,
-        18,
-        70,
-        156,
-        148,
-        109,
-        161,
-        34
-      ],
-      accounts: [
-        {
-          name: "user",
-          docs: [
-            "User performing the withdrawal"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (underlying token: SOL, BTC, ETH, USDC)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (Jupiter Lend token) - used for NAV calculation"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint (vault share token) - STV is mint authority",
-            "Verified against STV.jv_mint in handler"
-          ],
-          writable: true
-        },
-        {
-          name: "user_base_ata",
-          docs: [
-            "User's base asset token account (destination for withdrawal)"
-          ],
-          writable: true
-        },
-        {
-          name: "user_jvx_ata",
-          docs: [
-            "User's jvX token account (source - shares to burn)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (source for base tokens to user)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (used for NAV calculation)"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "shares_to_burn",
-          type: "u64"
-        }
-      ]
-    }
-  ],
-  accounts: [
-    {
-      name: "JLPVault",
-      discriminator: [
-        41,
-        108,
-        189,
-        168,
-        199,
-        152,
-        221,
-        119
-      ]
-    },
-    {
-      name: "STV",
-      discriminator: [
-        214,
-        2,
-        96,
-        41,
-        85,
-        163,
-        17,
-        230
-      ]
-    }
-  ],
-  events: [
-    {
-      name: "Deposited",
-      discriminator: [
-        111,
-        141,
-        26,
-        45,
-        161,
-        35,
-        100,
-        57
-      ]
-    },
-    {
-      name: "FeesClaimSkipped",
-      discriminator: [
-        7,
-        214,
-        20,
-        27,
-        90,
-        132,
-        198,
-        77
-      ]
-    },
-    {
-      name: "FeesClaimed",
-      discriminator: [
-        22,
-        104,
-        110,
-        222,
-        38,
-        157,
-        14,
-        62
-      ]
-    },
-    {
-      name: "JlpSwapped",
-      discriminator: [
-        253,
-        47,
-        169,
-        18,
-        222,
-        203,
-        169,
-        15
-      ]
-    },
-    {
-      name: "JlpVaultInitialized",
-      discriminator: [
-        52,
-        94,
-        202,
-        211,
-        2,
-        98,
-        77,
-        229
-      ]
-    },
-    {
-      name: "JlpVaultUpdated",
-      discriminator: [
-        20,
-        204,
-        5,
-        243,
-        122,
-        9,
-        109,
-        130
-      ]
-    },
-    {
-      name: "JlxMoved",
-      discriminator: [
-        251,
-        80,
-        253,
-        180,
-        106,
-        69,
-        129,
-        70
-      ]
-    },
-    {
-      name: "JlxSwapped",
-      discriminator: [
-        200,
-        218,
-        196,
-        94,
-        186,
-        141,
-        86,
-        223
-      ]
-    },
-    {
-      name: "JupEarnEvent",
-      discriminator: [
-        138,
-        10,
-        64,
-        209,
-        244,
-        49,
-        1,
-        188
-      ]
-    },
-    {
-      name: "SettleYieldEvent",
-      discriminator: [
-        208,
-        142,
-        20,
-        32,
-        204,
-        216,
-        242,
-        189
-      ]
-    },
-    {
-      name: "SettleYieldSkipped",
-      discriminator: [
-        189,
-        221,
-        140,
-        115,
-        37,
-        102,
-        42,
-        195
-      ]
-    },
-    {
-      name: "SettleYieldStvEvent",
-      discriminator: [
-        12,
-        42,
-        226,
-        95,
-        60,
-        95,
-        192,
-        238
-      ]
-    },
-    {
-      name: "StvInitialized",
-      discriminator: [
-        41,
-        106,
-        196,
-        230,
-        138,
-        22,
-        195,
-        188
-      ]
-    },
-    {
-      name: "StvUpdated",
-      discriminator: [
-        108,
-        129,
-        139,
-        80,
-        212,
-        111,
-        83,
-        199
-      ]
-    },
-    {
-      name: "Withdrawn",
-      discriminator: [
-        20,
-        89,
-        223,
-        198,
-        194,
-        124,
-        219,
-        13
-      ]
-    }
-  ],
-  errors: [
-    {
-      code: 6e3,
-      name: "Unauthorized",
-      msg: "Unauthorized: not admin"
-    },
-    {
-      code: 6001,
-      name: "NotManager",
-      msg: "Unauthorized: not manager"
-    },
-    {
-      code: 6002,
-      name: "VaultPaused",
-      msg: "Vault is paused"
-    },
-    {
-      code: 6003,
-      name: "DepositsDisabled",
-      msg: "Deposits disabled"
-    },
-    {
-      code: 6004,
-      name: "WithdrawalsDisabled",
-      msg: "Withdrawals disabled"
-    },
-    {
-      code: 6005,
-      name: "JlpDisabled",
-      msg: "JLP operations disabled"
-    },
-    {
-      code: 6006,
-      name: "RebalanceDisabled",
-      msg: "Rebalance operations disabled"
-    },
-    {
-      code: 6007,
-      name: "MathOverflow",
-      msg: "Math overflow"
-    },
-    {
-      code: 6008,
-      name: "InvalidTimestamp",
-      msg: "Invalid timestamp"
-    },
-    {
-      code: 6009,
-      name: "DivisionByZero",
-      msg: "Division by zero"
-    },
-    {
-      code: 6010,
-      name: "StagingNotZero",
-      msg: "Staging ATAs must be zero"
-    },
-    {
-      code: 6011,
-      name: "InsufficientLiquidity",
-      msg: "Insufficient liquidity for withdrawal"
-    },
-    {
-      code: 6012,
-      name: "InsufficientBalance",
-      msg: "Insufficient balance"
-    },
-    {
-      code: 6013,
-      name: "SlippageExceeded",
-      msg: "Slippage exceeded"
-    },
-    {
-      code: 6014,
-      name: "InvalidJlpVaultBump",
-      msg: "Invalid JLP vault PDA bump"
-    },
-    {
-      code: 6015,
-      name: "InvalidStvBump",
-      msg: "Invalid STV PDA bump"
-    },
-    {
-      code: 6016,
-      name: "InvalidJlMint",
-      msg: "Invalid jlX mint (Jupiter Lend token)"
-    },
-    {
-      code: 6017,
-      name: "InvalidJvMint",
-      msg: "Invalid jvX mint (vault share token)"
-    },
-    {
-      code: 6018,
-      name: "InvalidBaseMint",
-      msg: "Invalid base asset mint"
-    },
-    {
-      code: 6019,
-      name: "InvalidJlpMint",
-      msg: "Invalid JLP mint"
-    },
-    {
-      code: 6020,
-      name: "InvalidOwner",
-      msg: "Invalid account owner"
-    },
-    {
-      code: 6021,
-      name: "InvalidStvIndex",
-      msg: "Invalid STV index"
-    },
-    {
-      code: 6022,
-      name: "InvalidFeeParams",
-      msg: "Invalid fee parameters"
-    },
-    {
-      code: 6023,
-      name: "AmountTooSmall",
-      msg: "Amount too small"
-    },
-    {
-      code: 6024,
-      name: "ZeroAmount",
-      msg: "Zero amount not allowed"
-    },
-    {
-      code: 6025,
-      name: "FeeCapExceeded",
-      msg: "Fee cap exceeded"
-    },
-    {
-      code: 6026,
-      name: "MintMismatch",
-      msg: "Mint mismatch"
-    },
-    {
-      code: 6027,
-      name: "InsufficientAccounts",
-      msg: "Insufficient accounts provided"
-    },
-    {
-      code: 6028,
-      name: "InvalidProgram",
-      msg: "Invalid program ID"
-    },
-    {
-      code: 6029,
-      name: "InvalidSwapDiscriminator",
-      msg: "Invalid swap discriminator"
-    },
-    {
-      code: 6030,
-      name: "MaxDepositExceeded",
-      msg: "Deposit exceeds maximum allowed"
-    },
-    {
-      code: 6031,
-      name: "InvalidLendingAccount",
-      msg: "Invalid Jupiter Lend lending account"
-    },
-    {
-      code: 6032,
-      name: "MissingExchangeRateAccounts",
-      msg: "Missing exchange rate accounts - lending and rewards_rate_model required for pools with Jupiter Earn"
-    },
-    {
-      code: 6033,
-      name: "JupiterLendCpiFailed",
-      msg: "Jupiter Lend CPI failed"
-    },
-    {
-      code: 6034,
-      name: "JupiterSwapCpiFailed",
-      msg: "Jupiter swap CPI failed"
-    },
-    {
-      code: 6035,
-      name: "OracleStale",
-      msg: "Oracle price is stale - older than staleness threshold"
-    },
-    {
-      code: 6036,
-      name: "OraclePriceNegative",
-      msg: "Oracle returned negative price"
-    },
-    {
-      code: 6037,
-      name: "InvalidBaseAssetIndex",
-      msg: "Invalid base asset index"
-    },
-    {
-      code: 6038,
-      name: "PriceFeedMismatch",
-      msg: "Price feed mismatch"
-    },
-    {
-      code: 6039,
-      name: "OracleAccountInvalid",
-      msg: "Oracle account invalid"
-    },
-    {
-      code: 6040,
-      name: "InvalidAccountData",
-      msg: "Invalid account data - could not parse account"
-    },
-    {
-      code: 6041,
-      name: "InvalidExchangeRate",
-      msg: "Invalid exchange rate from Jupiter Lend"
-    },
-    {
-      code: 6042,
-      name: "InvalidOracleAccount",
-      msg: "Invalid oracle account - not owned by expected program"
-    },
-    {
-      code: 6043,
-      name: "JlpPriceOutOfRange",
-      msg: "JLP price out of reasonable range ($0.50 - $50.00)"
-    },
-    {
-      code: 6044,
-      name: "TestModeRequired",
-      msg: "Test mode required: FLAG_TEST_MODE must be set for devnet/localnet builds"
-    },
-    {
-      code: 6045,
-      name: "NotAdmin",
-      msg: "Unauthorized: not admin"
-    }
-  ],
-  types: [
-    {
-      name: "Deposited",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "user",
-            type: "pubkey"
-          },
-          {
-            name: "amount_base",
-            docs: [
-              "Amount of base asset deposited"
-            ],
-            type: "u64"
-          },
-          {
-            name: "shares_minted",
-            type: "u64"
-          },
-          {
-            name: "pps",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "Direction",
-      docs: [
-        "Direction of jlX token movement between STV and Vault"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "ToVault"
-          },
-          {
-            name: "FromVault"
-          }
-        ]
-      }
-    },
-    {
-      name: "FeesClaimSkipped",
-      docs: [
-        "Event emitted when claim_fees returns early (no fees to claim)"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "reason",
-            docs: [
-              'Reason for skipping: "NoFeesToClaim"'
-            ],
-            type: "string"
-          }
-        ]
-      }
-    },
-    {
-      name: "FeesClaimed",
-      docs: [
-        "Fee claim event - when manager claims accrued fees"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "amount_jlx",
-            docs: [
-              "Total jlX claimed by fee receiver"
-            ],
-            type: "u64"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Fee receiver who received the fees"
-            ],
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "InitOrUpdateJlpVaultParams",
-      docs: [
-        "Parameters for initializing or updating the JLP Vault"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "jlp_mint",
-            docs: [
-              "JLP token mint - required for init, ignored on update"
-            ],
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "base_asset_mints",
-            docs: [
-              "Base asset token mints [BTC, ETH, SOL, USDC, JupUSD] - required for init, ignored on update"
-            ],
-            type: {
-              option: {
-                array: [
-                  "pubkey",
-                  5
-                ]
-              }
-            }
-          },
-          {
-            name: "jlx_asset_mints",
-            docs: [
-              "jlX token mints [jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD] - required for init, ignored on update"
-            ],
-            type: {
-              option: {
-                array: [
-                  "pubkey",
-                  5
-                ]
-              }
-            }
-          },
-          {
-            name: "new_admin",
-            docs: [
-              "New admin address - if Some, transfers admin ownership (only current admin can do this)"
-            ],
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "manager",
-            docs: [
-              "Manager address (can perform rebalance operations)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Fee receiver address"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "flags",
-            docs: [
-              "Vault flags (paused, deposits disabled, etc.)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "jlp_slippage_bps",
-            docs: [
-              "JLP swap slippage tolerance in basis points (e.g., 100 = 1%)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "oracle_staleness_threshold",
-            docs: [
-              "Maximum age in seconds for Doves oracle prices to be considered valid.",
-              "On init: defaults to 60 seconds if None.",
-              "On update: if None, keeps existing value; if Some, updates to new value."
-            ],
-            type: {
-              option: "u64"
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "InitializeStvParams",
-      docs: [
-        "Parameters for initializing an STV"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "mgmt_fee_bps",
-            docs: [
-              "Management fee in basis points (annual)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "perf_fee_bps",
-            docs: [
-              "Performance fee in basis points"
-            ],
-            type: "u16"
-          },
-          {
-            name: "max_deposit",
-            docs: [
-              "Maximum deposit amount in base asset (0 = unlimited)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "min_deposit",
-            docs: [
-              "Minimum deposit amount in base asset (0 = no minimum)"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JLPVault",
-      docs: [
-        "JLPVault - Global vault configuration account",
-        'Seeds: ["jlp_vault"]',
-        "Size: 8 (discriminator) + 464 (data) = 472 bytes",
-        "",
-        "## USD-Based Settlement Model",
-        "This vault uses USD-based settlement where JLP positions are tracked via",
-        "each STV's `base_loaned` field. Yield is settled by marking `base_loaned`",
-        "to market using Doves oracle prices."
-      ],
-      serialization: "bytemuck",
-      repr: {
-        kind: "c"
-      },
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "admin",
-            docs: [
-              "Admin who can update vault configuration"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "manager",
-            docs: [
-              "Manager who can perform rebalance operations"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Account that receives fees"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jlp_mint",
-            docs: [
-              "JLP token mint address"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "base_asset_mints",
-            docs: [
-              "Base asset token mints [BTC, ETH, SOL, USDC, JupUSD]"
-            ],
-            type: {
-              array: [
-                "pubkey",
-                5
-              ]
-            }
-          },
-          {
-            name: "jlx_asset_mints",
-            docs: [
-              "jlX token mints [jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD]"
-            ],
-            type: {
-              array: [
-                "pubkey",
-                5
-              ]
-            }
-          },
-          {
-            name: "oracle_staleness_threshold",
-            docs: [
-              "Maximum age in seconds for Doves oracle prices to be considered valid.",
-              "Used during yield settlement to ensure price freshness.",
-              "Default: 60 seconds. Setting to 0 disables staleness check (not recommended)."
-            ],
-            type: "u64"
-          },
-          {
-            name: "flags",
-            docs: [
-              "Vault state flags"
-            ],
-            type: "u16"
-          },
-          {
-            name: "jlp_slippage_bps",
-            docs: [
-              "JLP swap slippage tolerance in basis points (e.g., 100 = 1%)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "version",
-            docs: [
-              "Account version for migrations"
-            ],
-            type: "u8"
-          },
-          {
-            name: "bump",
-            docs: [
-              "PDA bump seed"
-            ],
-            type: "u8"
-          },
-          {
-            name: "reserved",
-            docs: [
-              "Reserved for 8-byte alignment"
-            ],
-            type: {
-              array: [
-                "u8",
-                2
-              ]
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpSwapped",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "stv_index",
-            type: "u8"
-          },
-          {
-            name: "amount_in",
-            type: "u64"
-          },
-          {
-            name: "amount_out",
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = JlxToJlp, 1 = JlpToJlx"
-            ],
-            type: "u8"
-          },
-          {
-            name: "jlp_balance_before",
-            type: "u64"
-          },
-          {
-            name: "jlp_balance_after",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpVaultInitialized",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "admin",
-            type: "pubkey"
-          },
-          {
-            name: "manager",
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "jlp_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpVaultUpdated",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "old_manager",
-            type: "pubkey"
-          },
-          {
-            name: "new_manager",
-            type: "pubkey"
-          },
-          {
-            name: "old_fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "new_fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "old_flags",
-            type: "u16"
-          },
-          {
-            name: "new_flags",
-            type: "u16"
-          },
-          {
-            name: "old_jlp_slippage_bps",
-            type: "u16"
-          },
-          {
-            name: "new_jlp_slippage_bps",
-            type: "u16"
-          },
-          {
-            name: "old_oracle_staleness_threshold",
-            type: "u64"
-          },
-          {
-            name: "new_oracle_staleness_threshold",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlxMoved",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "amount_jlx",
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = ToVault (STV -> Vault), 1 = FromVault (Vault -> STV)"
-            ],
-            type: "u8"
-          },
-          {
-            name: "base_value",
-            docs: [
-              "Base asset value of the jlX moved (at current exchange rate)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "exchange_rate",
-            docs: [
-              "Jupiter Lend exchange rate used for calculation (12 decimals)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "new_base_loaned",
-            docs: [
-              "New base_loaned after the move"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlxSwapped",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "from_index",
-            type: "u8"
-          },
-          {
-            name: "to_index",
-            type: "u8"
-          },
-          {
-            name: "amount_in",
-            type: "u64"
-          },
-          {
-            name: "min_out",
-            type: "u64"
-          },
-          {
-            name: "amount_out",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnDirection",
-      docs: [
-        "Direction for Jupiter Earn operations"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "Deposit"
-          },
-          {
-            name: "Withdraw"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnEvent",
-      docs: [
-        "Event emitted for Jupiter Earn deposit/withdraw operations"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = Deposit (base -> jlX), 1 = Withdraw (jlX -> base)"
-            ],
-            type: "u8"
-          },
-          {
-            name: "base_amount",
-            docs: [
-              "Amount of base asset (deposited or received)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "jlx_amount",
-            docs: [
-              "Amount of jlX (received or burned)"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnParams",
-      docs: [
-        "Parameters for Jupiter Earn deposit/withdraw"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "direction",
-            docs: [
-              "Direction of the operation"
-            ],
-            type: {
-              defined: {
-                name: "JupEarnDirection"
-              }
-            }
-          },
-          {
-            name: "amount",
-            docs: [
-              "Amount to deposit (base) or withdraw (jlX)"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "MoveJlxParams",
-      docs: [
-        "Parameters for moving jlX tokens between STV and Vault"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "amount_jlx",
-            docs: [
-              "Amount of jlX tokens to move"
-            ],
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction of the transfer"
-            ],
-            type: {
-              defined: {
-                name: "Direction"
-              }
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "STV",
-      docs: [
-        "STV - Single Token Vault account",
-        'Seeds: ["stv", base_mint.key().as_ref()]',
-        "Size: 8 (discriminator) + 160 (data) = 168 bytes"
-      ],
-      serialization: "bytemuck",
-      repr: {
-        kind: "c"
-      },
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "base_mint",
-            docs: [
-              "Base asset mint (BTC, ETH, SOL, or USDC)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jl_mint",
-            docs: [
-              "Jupiter Lend token mint (jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jv_mint",
-            docs: [
-              "Vault share token mint (jvBTC, jvETH, jvSOL, jvUSDC, jvJupUSD)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "pps",
-            docs: [
-              "Price per share in base asset terms (scaled by PPS_DECIMALS)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "hwm",
-            docs: [
-              "High water mark for performance fee (scaled by PPS_DECIMALS)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "last_mgmt_fee_ts",
-            docs: [
-              "Timestamp of last management fee accrual"
-            ],
-            type: "u64"
-          },
-          {
-            name: "base_loaned",
-            docs: [
-              "Base asset value loaned to JLP Vault (illiquid assets)",
-              "Updated on: move_stv_to_from_vault (+/-), settle_yield (+/-)",
-              "Denominated in base asset (SOL, BTC, etc.), NOT jlX"
-            ],
-            type: "u64"
-          },
-          {
-            name: "accrued_fees_jlx",
-            docs: [
-              "Accrued fees in jlX terms (unclaimed, reduces effective NAV for PPS)",
-              "Updated on: crystallize_fees (+), claim_fees (reset to 0)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "max_deposit",
-            docs: [
-              "Maximum deposit amount in base asset (0 = unlimited)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "min_deposit",
-            docs: [
-              "Minimum deposit amount in base asset (0 = no minimum)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "mgmt_fee_bps",
-            docs: [
-              "Management fee in basis points (annual)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "perf_fee_bps",
-            docs: [
-              "Performance fee in basis points"
-            ],
-            type: "u16"
-          },
-          {
-            name: "flags",
-            docs: [
-              "STV state flags"
-            ],
-            type: "u16"
-          },
-          {
-            name: "version",
-            docs: [
-              "Account version for migrations"
-            ],
-            type: "u8"
-          },
-          {
-            name: "bump",
-            docs: [
-              "PDA bump seed"
-            ],
-            type: "u8"
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldEvent",
-      docs: [
-        "Aggregate yield settlement event - emitted once per settle_yield call"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            docs: [
-              "The JLP vault"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "vault_usd",
-            docs: [
-              "Total vault USD value (JLP + staging jlX) with 6 decimals"
-            ],
-            type: "u128"
-          },
-          {
-            name: "total_loaned_usd",
-            docs: [
-              "Total base_loaned USD value across all STVs with 6 decimals"
-            ],
-            type: "u128"
-          },
-          {
-            name: "delta_usd",
-            docs: [
-              "Absolute delta between vault_usd and total_loaned_usd"
-            ],
-            type: "u128"
-          },
-          {
-            name: "is_surplus",
-            docs: [
-              "True if vault_usd >= total_loaned_usd (yield), false if deficit (bad debt)"
-            ],
-            type: "bool"
-          },
-          {
-            name: "timestamp",
-            docs: [
-              "Settlement timestamp"
-            ],
-            type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldSkipped",
-      docs: [
-        "Event emitted when settle_yield returns early (no loans outstanding)"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            docs: [
-              "The JLP vault"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "reason",
-            docs: [
-              'Reason for skipping: "NoLoansOutstanding"'
-            ],
-            type: "string"
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldStvEvent",
-      docs: [
-        "Per-STV yield settlement event - emitted for each STV with non-zero base_loaned"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "old_base_loaned",
-            docs: [
-              "base_loaned before settlement"
-            ],
-            type: "u64"
-          },
-          {
-            name: "new_base_loaned",
-            docs: [
-              "base_loaned after settlement"
-            ],
-            type: "u64"
-          },
-          {
-            name: "adjustment_base",
-            docs: [
-              "Adjustment amount in base asset terms"
-            ],
-            type: "u64"
-          },
-          {
-            name: "is_surplus",
-            docs: [
-              "True if surplus (yield added), false if deficit (bad debt deducted)"
-            ],
-            type: "bool"
-          }
-        ]
-      }
-    },
-    {
-      name: "StvInitialized",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "base_mint",
-            type: "pubkey"
-          },
-          {
-            name: "jl_mint",
-            type: "pubkey"
-          },
-          {
-            name: "jv_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "StvUpdated",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "base_mint",
-            type: "pubkey"
-          },
-          {
-            name: "old_mgmt_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "new_mgmt_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "old_perf_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "new_perf_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "old_flags",
-            type: "u16"
-          },
-          {
-            name: "new_flags",
-            type: "u16"
-          },
-          {
-            name: "old_max_deposit",
-            type: "u64"
-          },
-          {
-            name: "new_max_deposit",
-            type: "u64"
-          },
-          {
-            name: "old_min_deposit",
-            type: "u64"
-          },
-          {
-            name: "new_min_deposit",
-            type: "u64"
-          },
-          {
-            name: "old_jl_mint",
-            type: "pubkey"
-          },
-          {
-            name: "new_jl_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "SwapDirection",
-      docs: [
-        "Direction of the swap operation"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "JlxToJlp"
-          },
-          {
-            name: "JlpToJlx"
-          }
-        ]
-      }
-    },
-    {
-      name: "SwapJlxJlpParams",
-      docs: [
-        "Parameters for the swap instruction"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv_index",
-            docs: [
-              "Which STV this JLP belongs to (0-4: BTC, ETH, SOL, USDC, JupUSD)"
-            ],
-            type: "u8"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction of the swap"
-            ],
-            type: {
-              defined: {
-                name: "SwapDirection"
-              }
-            }
-          },
-          {
-            name: "amount_in",
-            docs: [
-              "Amount of input token being swapped"
-            ],
-            type: "u64"
-          },
-          {
-            name: "expected_amount_out",
-            docs: [
-              "Expected output amount (used for devnet mock, verified on mainnet)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "jupiter_data",
-            docs: [
-              "Jupiter swap instruction data (includes discriminator and route)",
-              "This is obtained from Jupiter API off-chain",
-              "On devnet (with `devnet` feature), this can be empty"
-            ],
-            type: "bytes"
-          }
-        ]
-      }
-    },
-    {
-      name: "UpdateStvParams",
-      docs: [
-        "Parameters for updating an STV"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "mgmt_fee_bps",
-            docs: [
-              "Management fee in basis points (annual)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "perf_fee_bps",
-            docs: [
-              "Performance fee in basis points"
-            ],
-            type: "u16"
-          },
-          {
-            name: "flags",
-            docs: [
-              "STV state flags"
-            ],
-            type: "u16"
-          },
-          {
-            name: "max_deposit",
-            docs: [
-              "Maximum deposit amount in base asset (0 = unlimited)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "min_deposit",
-            docs: [
-              "Minimum deposit amount in base asset (0 = no minimum)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "jl_mint",
-            docs: [
-              "Optional new jl_mint for migrating base-only pools to Jupiter Lend"
-            ],
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "pps",
-            docs: [
-              "Override price per share (9 decimals, e.g. 1_000_000_000 = 1.0)"
-            ],
-            type: {
-              option: "u64"
-            }
-          },
-          {
-            name: "hwm",
-            docs: [
-              "Override high water mark (9 decimals)"
-            ],
-            type: {
-              option: "u64"
-            }
-          },
-          {
-            name: "base_loaned",
-            docs: [
-              "Override base_loaned accounting field"
-            ],
-            type: {
-              option: "u64"
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "Withdrawn",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "user",
-            type: "pubkey"
-          },
-          {
-            name: "shares_burned",
-            type: "u64"
-          },
-          {
-            name: "amount_base",
-            docs: [
-              "Amount of base asset withdrawn"
-            ],
-            type: "u64"
-          },
-          {
-            name: "pps",
-            type: "u64"
-          }
-        ]
-      }
-    }
-  ]
-};
-
-// src/program.ts
-var DUMMY_WALLET = {
-  publicKey: import_web3.Keypair.generate().publicKey,
-  signTransaction: async (tx) => tx,
-  signAllTransactions: async (txs) => txs
-};
-function createProgram(connection) {
-  const provider = new import_anchor.AnchorProvider(connection, DUMMY_WALLET, {
-    commitment: "confirmed"
-  });
-  return new import_anchor.Program(jlp_d_program_default, provider);
-}
-
-// src/constants.ts
-var import_web32 = require("@solana/web3.js");
-var import_spl_token = require("@solana/spl-token");
-var JLPD_PROGRAM_ID = new import_web32.PublicKey(
-  "ELEM2bAobpZNuysfhyF28XGVjA1aTUwm6rPYyv1JX3oq"
-);
-var JUPITER_LEND_PROGRAM_ID = new import_web32.PublicKey(
-  "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"
-);
-var JUPITER_SWAP_PROGRAM_ID = new import_web32.PublicKey(
-  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
-);
-var SEED_JLP_VAULT = "jlp_vault";
-var SEED_STV = "stv";
-var FLAG_PAUSED = 1;
-var FLAG_DEPOSITS_DISABLED = 2;
-var FLAG_WITHDRAWALS_DISABLED = 4;
-var FLAG_JLP_DISABLED = 8;
-var FLAG_REBALANCE_DISABLED = 16;
-var PPS_DECIMALS = 1e9;
-var EXCHANGE_RATE_PRECISION = 1e12;
-var MINTS = {
-  JLP: new import_web32.PublicKey("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4"),
-  WSOL: import_spl_token.NATIVE_MINT,
-  USDC: new import_web32.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
-  WBTC: new import_web32.PublicKey("3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"),
-  WETH: new import_web32.PublicKey("7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"),
-  JupUSD: new import_web32.PublicKey("JuprjznTrTSp2UFa3ZBUFgwdAmtZCq4MQCwysN55USD")
-};
-var STV_INDEX = /* @__PURE__ */ ((STV_INDEX2) => {
-  STV_INDEX2[STV_INDEX2["BTC"] = 0] = "BTC";
-  STV_INDEX2[STV_INDEX2["ETH"] = 1] = "ETH";
-  STV_INDEX2[STV_INDEX2["SOL"] = 2] = "SOL";
-  STV_INDEX2[STV_INDEX2["USDC"] = 3] = "USDC";
-  STV_INDEX2[STV_INDEX2["JupUSD"] = 4] = "JupUSD";
-  return STV_INDEX2;
-})(STV_INDEX || {});
-var ORACLES = {
-  // Doves oracles (Jupiter Perps oracle system)
-  DOVES_BTC_USD: new import_web32.PublicKey("4HBbPx9QJdjJ7GUe6bsiJjGybvfpDhQMMPXP1UEa7VT5"),
-  DOVES_ETH_USD: new import_web32.PublicKey("5URYohbPy32nxK1t3jAHVNfdWY2xTubHiFvLrE3VhXEp"),
-  DOVES_SOL_USD: new import_web32.PublicKey("39cWjvHrpHNz2SbXv6ME4NPhqBDBd4KsjUYv5JkHEAJU")
-};
-var JLP_POOL_PUBKEY = new import_web32.PublicKey("5BUwFW4nRbftYTDMbgxykoFWqWHPzahFSNAaaaJtVKsq");
-var JUPITER_PERPS_PROGRAM_ID = new import_web32.PublicKey("PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu");
-
-// src/accounts/pdas.ts
-var import_web33 = require("@solana/web3.js");
-var SEED_JLP_VAULT_BUFFER = Buffer.from(SEED_JLP_VAULT);
-var SEED_STV_BUFFER = Buffer.from(SEED_STV);
-var pdaCache = /* @__PURE__ */ new Map();
-function deriveVaultPda(programId) {
-  const key = `vault:${programId.toBase58()}`;
-  let cached = pdaCache.get(key);
-  if (!cached) {
-    cached = import_web33.PublicKey.findProgramAddressSync(
-      [SEED_JLP_VAULT_BUFFER],
-      programId
-    );
-    pdaCache.set(key, cached);
-  }
-  return cached;
-}
-function deriveStvPda(baseMint, programId) {
-  const key = `stv:${baseMint.toBase58()}:${programId.toBase58()}`;
-  let cached = pdaCache.get(key);
-  if (!cached) {
-    cached = import_web33.PublicKey.findProgramAddressSync(
-      [SEED_STV_BUFFER, baseMint.toBuffer()],
-      programId
-    );
-    pdaCache.set(key, cached);
-  }
-  return cached;
-}
-function clearPdaCache() {
-  pdaCache.clear();
-}
-
-// src/accounts/vault.ts
-var import_web34 = require("@solana/web3.js");
-var import_anchor2 = require("@coral-xyz/anchor");
-var JLP_VAULT_DATA_SIZE = 464;
-var JLP_VAULT_ACCOUNT_SIZE = 8 + JLP_VAULT_DATA_SIZE;
-var JLP_VAULT_DISCRIMINATOR = Buffer.from([
-  41,
-  108,
-  189,
-  168,
-  199,
-  152,
-  221,
-  119
-]);
-function parseVault(data) {
-  if (data.length < JLP_VAULT_ACCOUNT_SIZE) {
-    throw new Error(
-      `Invalid JLPVault data size: expected ${JLP_VAULT_ACCOUNT_SIZE}, got ${data.length}`
-    );
-  }
-  const discriminator = data.subarray(0, 8);
-  if (!discriminator.equals(JLP_VAULT_DISCRIMINATOR)) {
-    throw new Error(
-      `Invalid JLPVault discriminator: expected ${JLP_VAULT_DISCRIMINATOR.toString("hex")}, got ${discriminator.toString("hex")}`
-    );
-  }
-  let offset = 8;
-  const admin = new import_web34.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const manager = new import_web34.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const feeReceiver = new import_web34.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jlpMint = new import_web34.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const baseAssetMints = [];
-  for (let i = 0; i < 5; i++) {
-    baseAssetMints.push(new import_web34.PublicKey(data.subarray(offset, offset + 32)));
-    offset += 32;
-  }
-  const jlxAssetMints = [];
-  for (let i = 0; i < 5; i++) {
-    jlxAssetMints.push(new import_web34.PublicKey(data.subarray(offset, offset + 32)));
-    offset += 32;
-  }
-  const oracleStalenessThreshold = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const flags = data.readUInt16LE(offset);
-  offset += 2;
-  const jlpSlippageBps = data.readUInt16LE(offset);
-  offset += 2;
-  const version = data.readUInt8(offset);
-  offset += 1;
-  const bump = data.readUInt8(offset);
-  offset += 1;
-  return {
-    admin,
-    manager,
-    feeReceiver,
-    jlpMint,
-    baseAssetMints,
-    jlxAssetMints,
-    oracleStalenessThreshold,
-    flags,
-    jlpSlippageBps,
-    version,
-    bump
-  };
-}
-
-// src/accounts/stv.ts
-var import_web35 = require("@solana/web3.js");
-var import_anchor3 = require("@coral-xyz/anchor");
-var STV_DATA_SIZE = 160;
-var STV_ACCOUNT_SIZE = 8 + STV_DATA_SIZE;
-var STV_DISCRIMINATOR = Buffer.from([
-  214,
-  2,
-  96,
-  41,
-  85,
-  163,
-  17,
-  230
-]);
-function parseStv(data) {
-  if (data.length < STV_ACCOUNT_SIZE) {
-    throw new Error(
-      `Invalid STV data size: expected ${STV_ACCOUNT_SIZE}, got ${data.length}`
-    );
-  }
-  const discriminator = data.subarray(0, 8);
-  if (!discriminator.equals(STV_DISCRIMINATOR)) {
-    throw new Error(
-      `Invalid STV discriminator: expected ${STV_DISCRIMINATOR.toString("hex")}, got ${discriminator.toString("hex")}`
-    );
-  }
-  let offset = 8;
-  const baseMint = new import_web35.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jlMint = new import_web35.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jvMint = new import_web35.PublicKey(data.subarray(offset, offset + 32));
-  offset += 32;
-  const pps = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const hwm = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const lastMgmtFeeTs = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const baseLoaned = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const accruedFeesJlx = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const maxDeposit = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const minDeposit = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const mgmtFeeBps = data.readUInt16LE(offset);
-  offset += 2;
-  const perfFeeBps = data.readUInt16LE(offset);
-  offset += 2;
-  const flags = data.readUInt16LE(offset);
-  offset += 2;
-  const version = data.readUInt8(offset);
-  offset += 1;
-  const bump = data.readUInt8(offset);
-  offset += 1;
-  return {
-    baseMint,
-    jlMint,
-    jvMint,
-    pps,
-    hwm,
-    lastMgmtFeeTs,
-    baseLoaned,
-    accruedFeesJlx,
-    maxDeposit,
-    minDeposit,
-    mgmtFeeBps,
-    perfFeeBps,
-    flags,
-    version,
-    bump
-  };
-}
-
-// src/utils/ata.ts
-var import_spl_token2 = require("@solana/spl-token");
-var ataCache = /* @__PURE__ */ new Map();
-function deriveAta(mint, owner, allowPda = false) {
-  const key = `${mint.toBase58()}:${owner.toBase58()}:${allowPda}`;
-  let cached = ataCache.get(key);
-  if (!cached) {
-    cached = (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, owner, allowPda);
-    ataCache.set(key, cached);
-  }
-  return cached;
-}
-function deriveUserAtas(baseMint, jvMint, userWallet) {
-  return {
-    baseAta: deriveAta(baseMint, userWallet, false),
-    jvxAta: deriveAta(jvMint, userWallet, false)
-  };
-}
-function deriveStvAtas(baseMint, jlxMint, stvPda) {
-  return {
-    baseAta: deriveAta(baseMint, stvPda, true),
-    jlxAta: deriveAta(jlxMint, stvPda, true)
-  };
-}
-function deriveVaultAtas(jlxMint, jlpMint, vaultPda) {
-  return {
-    stagingAta: deriveAta(jlxMint, vaultPda, true),
-    jlpAta: deriveAta(jlpMint, vaultPda, true)
-  };
-}
-function clearAtaCache() {
-  ataCache.clear();
-}
-
-// src/utils/math.ts
-var import_anchor4 = require("@coral-xyz/anchor");
-var PPS_DECIMALS_BN = new import_anchor4.BN(PPS_DECIMALS);
-var EXCHANGE_RATE_PRECISION_BN = new import_anchor4.BN(EXCHANGE_RATE_PRECISION);
-var EXCHANGE_RATE_PRECISION_BI = BigInt(EXCHANGE_RATE_PRECISION);
-var RETURN_PERCENT_PRECISION = EXCHANGE_RATE_PRECISION_BI * 100n;
-var SECONDS_PER_YEAR = BigInt(365 * 24 * 60 * 60);
-var MAX_REWARDS_RATE = 50n * EXCHANGE_RATE_PRECISION_BI;
-function calculateNav(stvBaseBalance, stvJlxBalance, exchangeRate, baseLoaned) {
-  const jlxValue = stvJlxBalance.mul(new import_anchor4.BN(exchangeRate.toString())).div(EXCHANGE_RATE_PRECISION_BN);
-  return stvBaseBalance.add(jlxValue).add(baseLoaned);
-}
-function calculatePps(nav, jvSupply) {
-  if (jvSupply.isZero()) {
-    return new import_anchor4.BN(PPS_DECIMALS);
-  }
-  return nav.mul(PPS_DECIMALS_BN).div(jvSupply);
-}
-function sharesToBase(shares, pps) {
-  if (pps.isZero()) {
-    throw new Error("Price per share cannot be zero");
-  }
-  return shares.mul(pps).div(PPS_DECIMALS_BN);
-}
-function baseToShares(base, pps) {
-  if (pps.isZero()) {
-    throw new Error("Price per share cannot be zero");
-  }
-  return base.mul(PPS_DECIMALS_BN).div(pps);
-}
-function jlxToBase(jlxAmount, exchangeRate) {
-  if (exchangeRate.isZero()) {
-    throw new Error("Exchange rate cannot be zero");
-  }
-  return jlxAmount.mul(exchangeRate).div(EXCHANGE_RATE_PRECISION_BN);
-}
-function baseToJlx(baseAmount, exchangeRate) {
-  if (exchangeRate.isZero()) {
-    throw new Error("Exchange rate cannot be zero");
-  }
-  return baseAmount.mul(EXCHANGE_RATE_PRECISION_BN).div(exchangeRate);
-}
-function calculateExchangeRate(storedRate, rewardsRate, currentTimestamp, lastUpdateTimestamp, fTokenTotalSupply) {
-  if (fTokenTotalSupply === 0n) {
-    return storedRate;
-  }
-  const totalAssets = storedRate * fTokenTotalSupply / EXCHANGE_RATE_PRECISION_BI;
-  if (totalAssets === 0n || rewardsRate === 0n) {
-    return storedRate;
-  }
-  const timeDiff = currentTimestamp - lastUpdateTimestamp;
-  if (timeDiff <= 0n) {
-    return storedRate;
-  }
-  const rate = rewardsRate * RETURN_PERCENT_PRECISION / totalAssets;
-  const cappedRate = rate > MAX_REWARDS_RATE ? MAX_REWARDS_RATE : rate;
-  const priceIncrease = storedRate * cappedRate * timeDiff / RETURN_PERCENT_PRECISION / SECONDS_PER_YEAR;
-  return storedRate + priceIncrease;
-}
-
-// src/jupiter/pools.ts
-var import_web36 = require("@solana/web3.js");
-var import_spl_token3 = require("@solana/spl-token");
-var LENDING_ADMIN = new import_web36.PublicKey("5nmGjA4s7ATzpBQXC5RNceRpaJ7pYw2wKsNBWyuSAZV6");
-var LIQUIDITY_PROGRAM_ID = new import_web36.PublicKey("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC");
-var LIQUIDITY_SINGLETON = new import_web36.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z");
-var WSOL_POOL = {
-  mint: import_spl_token3.NATIVE_MINT,
-  name: "SOL",
-  lending: new import_web36.PublicKey("BeAqbxfrcXmzEYT2Ra62oW2MqkuFDHaCtps47Mzg6Zj3"),
-  fTokenMint: new import_web36.PublicKey("2uQsyo1fXXQkDtcpXnLofWy88PxcvnfH2L8FPSE62FVU"),
-  tokenReservesLiquidity: new import_web36.PublicKey("4Y66HtUEqbbbpZdENGtFdVhUMS3tnagffn3M4do59Nfy"),
-  supplyPositionOnLiquidity: new import_web36.PublicKey("4SkEYxmiRgQ4VYyvh9VB4k39M49BpqazyzDUFDzJhXQm"),
-  rewardsRateModel: new import_web36.PublicKey("CkeQGDRsgMZcCaU8cZEdC2aFAohia4jLzL36RaLcUDsR"),
-  vault: new import_web36.PublicKey("5JP5zgYCb9W37QQLgAHRHuinFLrKt87akDY1CgZoTPzr"),
-  rateModel: new import_web36.PublicKey("Acvyi9HBGmqh3Exe1N4PjBVyY8fokq2AdC6fSLqV6KSo"),
-  claimAccount: new import_web36.PublicKey("6AQGR8zK4KTVZfZ9UZaRzyEL5ynvwVaF5ywVdmtJT24N"),
-  decimals: 9,
-  stvIndex: 2 /* SOL */,
-  hasJupiterLend: true,
-  jupDirectSwap: false
-};
-var USDC_POOL = {
-  mint: MINTS.USDC,
-  name: "USDC",
-  lending: new import_web36.PublicKey("2vVYHYM8VYnvZqQWpTJSj8o8DBf1wM8pVs3bsTgYZiqJ"),
-  fTokenMint: new import_web36.PublicKey("9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D"),
-  tokenReservesLiquidity: new import_web36.PublicKey("94vK29npVbyRHXH63rRcTiSr26SFhrQTzbpNJuhQEDu"),
-  supplyPositionOnLiquidity: new import_web36.PublicKey("Hf9gtkM4dpVBahVSzEXSVCAPpKzBsBcns3s8As3z77oF"),
-  rewardsRateModel: new import_web36.PublicKey("5xSPBiD3TibamAnwHDhZABdB4z4F9dcj5PnbteroBTTd"),
-  vault: new import_web36.PublicKey("BmkUoKMFYBxNSzWXyUjyMJjMAaVz4d8ZnxwwmhDCUXFB"),
-  rateModel: new import_web36.PublicKey("5pjzT5dFTsXcwixoab1QDLvZQvpYJxJeBphkyfHGn688"),
-  claimAccount: new import_web36.PublicKey("HN1r4VfkDn53xQQfeGDYrNuDKFdemAhZsHYRwBrFhsW"),
-  decimals: 6,
-  stvIndex: 3 /* USDC */,
-  hasJupiterLend: true,
-  jupDirectSwap: true
-};
-var JUPUSD_POOL = {
-  mint: MINTS.JupUSD,
-  name: "JupUSD",
-  lending: new import_web36.PublicKey("papYEgeG5uPE4niUWZhihUUzVVotJn1mAWbYo2UBSHi"),
-  fTokenMint: new import_web36.PublicKey("7GxATsNMnaC88vdwd2t3mwrFuQwwGvmYPrUQ4D6FotXk"),
-  tokenReservesLiquidity: new import_web36.PublicKey("2tQE8jVR5ezDw3PDa21BNzfyQ14Ug5cTf6n3swJNjkod"),
-  supplyPositionOnLiquidity: new import_web36.PublicKey("DXFoJruECdEch2KpzLQ2cSpxoBSsyg4bpYPnHYofsbD4"),
-  rewardsRateModel: new import_web36.PublicKey("E3U32h49TL9Qof3NeLja9qJxTrGYpY1o1NQPtrSLJjcc"),
-  vault: new import_web36.PublicKey("9kGqd5zsQGaFfFPdUuEgbRM4V7x72Jdt7WTS4uRouAQ7"),
-  rateModel: new import_web36.PublicKey("2hT44GA9r5PiqsbbmqN5CuF7ymtquoEdokRncAs9CVej"),
-  claimAccount: new import_web36.PublicKey("6q9vTzAsTMEPUCwuhEdJSJdpRNXnubwKZbi2go1B8nvg"),
-  decimals: 6,
-  stvIndex: 4 /* JupUSD */,
-  hasJupiterLend: true,
-  jupDirectSwap: true
-};
-var WBTC_POOL = {
-  mint: MINTS.WBTC,
-  name: "BTC",
-  lending: import_web36.PublicKey.default,
-  fTokenMint: MINTS.WBTC,
-  // jlBTC = WBTC (base-only)
-  tokenReservesLiquidity: import_web36.PublicKey.default,
-  supplyPositionOnLiquidity: import_web36.PublicKey.default,
-  rewardsRateModel: import_web36.PublicKey.default,
-  vault: import_web36.PublicKey.default,
-  rateModel: import_web36.PublicKey.default,
-  claimAccount: import_web36.PublicKey.default,
-  decimals: 8,
-  stvIndex: 0 /* BTC */,
-  hasJupiterLend: false,
-  jupDirectSwap: true
-};
-var WETH_POOL = {
-  mint: MINTS.WETH,
-  name: "ETH",
-  lending: import_web36.PublicKey.default,
-  fTokenMint: MINTS.WETH,
-  // jlETH = WETH (base-only)
-  tokenReservesLiquidity: import_web36.PublicKey.default,
-  supplyPositionOnLiquidity: import_web36.PublicKey.default,
-  rewardsRateModel: import_web36.PublicKey.default,
-  vault: import_web36.PublicKey.default,
-  rateModel: import_web36.PublicKey.default,
-  claimAccount: import_web36.PublicKey.default,
-  decimals: 8,
-  stvIndex: 1 /* ETH */,
-  hasJupiterLend: false,
-  jupDirectSwap: true
-};
-var POOLS = {
-  SOL: WSOL_POOL,
-  USDC: USDC_POOL,
-  JupUSD: JUPUSD_POOL,
-  BTC: WBTC_POOL,
-  ETH: WETH_POOL
-};
-var POOLS_BY_MINT = new Map(
-  Object.values(POOLS).map((p) => [p.mint.toBase58(), p])
-);
-function getPoolByName(name) {
-  return POOLS[name];
-}
-function getPoolByMint(mint) {
-  return POOLS_BY_MINT.get(mint.toBase58());
-}
-
-// src/jupiter/lend.ts
-var import_web37 = require("@solana/web3.js");
-var import_spl_token4 = require("@solana/spl-token");
-var JUPITER_LEND_PROGRAM_ID2 = new import_web37.PublicKey(
-  "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"
-);
-function buildExchangeRateAccounts(pool) {
-  if (!pool.hasJupiterLend) {
-    return null;
-  }
-  return {
-    lending: pool.lending,
-    rewardsRateModel: pool.rewardsRateModel
-  };
-}
-function buildJupEarnDepositAccounts(pool, stvPda, stvBaseAta, stvJlxAta) {
-  if (!pool.hasJupiterLend) {
-    throw new Error(`Pool ${pool.name} does not support Jupiter Lend`);
-  }
-  return [
-    { pubkey: stvPda, isSigner: false, isWritable: true },
-    { pubkey: stvBaseAta, isSigner: false, isWritable: true },
-    { pubkey: stvJlxAta, isSigner: false, isWritable: true },
-    { pubkey: pool.mint, isSigner: false, isWritable: false },
-    { pubkey: LENDING_ADMIN, isSigner: false, isWritable: false },
-    { pubkey: pool.lending, isSigner: false, isWritable: true },
-    { pubkey: pool.fTokenMint, isSigner: false, isWritable: true },
-    { pubkey: pool.tokenReservesLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.supplyPositionOnLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.rateModel, isSigner: false, isWritable: false },
-    { pubkey: pool.vault, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_SINGLETON, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_PROGRAM_ID, isSigner: false, isWritable: true },
-    { pubkey: pool.rewardsRateModel, isSigner: false, isWritable: false },
-    { pubkey: import_spl_token4.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: import_spl_token4.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: import_web37.SystemProgram.programId, isSigner: false, isWritable: false },
-    { pubkey: JUPITER_LEND_PROGRAM_ID2, isSigner: false, isWritable: false }
-  ];
-}
-function buildJupEarnWithdrawAccounts(pool, stvPda, stvJlxAta, stvBaseAta) {
-  if (!pool.hasJupiterLend) {
-    throw new Error(`Pool ${pool.name} does not support Jupiter Lend`);
-  }
-  return [
-    { pubkey: stvPda, isSigner: false, isWritable: true },
-    { pubkey: stvJlxAta, isSigner: false, isWritable: true },
-    { pubkey: stvBaseAta, isSigner: false, isWritable: true },
-    { pubkey: LENDING_ADMIN, isSigner: false, isWritable: false },
-    { pubkey: pool.lending, isSigner: false, isWritable: true },
-    { pubkey: pool.mint, isSigner: false, isWritable: false },
-    { pubkey: pool.fTokenMint, isSigner: false, isWritable: true },
-    { pubkey: pool.tokenReservesLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.supplyPositionOnLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.rateModel, isSigner: false, isWritable: false },
-    { pubkey: pool.vault, isSigner: false, isWritable: true },
-    { pubkey: pool.claimAccount, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_SINGLETON, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_PROGRAM_ID, isSigner: false, isWritable: true },
-    { pubkey: pool.rewardsRateModel, isSigner: false, isWritable: false },
-    { pubkey: import_spl_token4.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: import_spl_token4.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: import_web37.SystemProgram.programId, isSigner: false, isWritable: false },
-    { pubkey: JUPITER_LEND_PROGRAM_ID2, isSigner: false, isWritable: false }
-  ];
-}
-function parseLendingAccount(data) {
-  return {
-    mint: new import_web37.PublicKey(data.slice(8, 40)),
-    fTokenMint: new import_web37.PublicKey(data.slice(40, 72)),
-    lendingId: data.readUInt16LE(72),
-    decimals: data[74],
-    rewardsRateModel: new import_web37.PublicKey(data.slice(75, 107)),
-    liquidityExchangePrice: data.readBigUInt64LE(107),
-    tokenExchangePrice: data.readBigUInt64LE(115),
-    lastUpdateTimestamp: data.readBigUInt64LE(123),
-    tokenReservesLiquidity: new import_web37.PublicKey(data.slice(131, 163)),
-    supplyPositionOnLiquidity: new import_web37.PublicKey(data.slice(163, 195)),
-    bump: data[195]
-  };
-}
-function parseRewardsRateModel(data) {
-  return {
-    mint: new import_web37.PublicKey(data.slice(8, 40)),
-    startTvl: data.readBigUInt64LE(40),
-    duration: data.readBigUInt64LE(48),
-    startTime: data.readBigUInt64LE(56),
-    yearlyReward: data.readBigUInt64LE(64),
-    nextDuration: data.readBigUInt64LE(72),
-    nextRewardAmount: data.readBigUInt64LE(80),
-    bump: data[88]
-  };
-}
-
-// src/jupiter/swap.ts
-var import_web38 = require("@solana/web3.js");
-var JUPITER_API_BASE = "https://api.jup.ag/swap/v1";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var MAX_RETRIES = 3;
-var RETRY_DELAY_MS = 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function fetchWithRetry(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS, retries = MAX_RETRIES) {
-  let lastError = null;
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        return response;
-      }
-      if (response.status >= 400 && response.status < 500) {
-        const errorText = await response.text();
-        throw new Error(`Jupiter API error (${response.status}): ${errorText}`);
-      }
-      lastError = new Error(`Jupiter API returned ${response.status}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          lastError = new Error(`Request timed out after ${timeoutMs}ms`);
-        } else {
-          lastError = error;
-        }
-      }
-    }
-    if (attempt < retries - 1) {
-      await sleep(RETRY_DELAY_MS * (attempt + 1));
-    }
-  }
-  throw lastError ?? new Error("Unknown error during fetch");
-}
-async function getJupiterQuote(inputMint, outputMint, amount, slippageBps = 50, maxAccounts = 40, apiKey) {
-  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 (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  const response = await fetchWithRetry(url, { headers });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Jupiter quote error: ${data.error}`);
-  }
-  return data;
-}
-async function getJupiterSwapInstructions(quote, userPubkey, apiKey) {
-  const url = `${JUPITER_API_BASE}/swap-instructions`;
-  const body = {
-    quoteResponse: quote,
-    userPublicKey: userPubkey.toBase58(),
-    wrapAndUnwrapSol: false,
-    dynamicComputeUnitLimit: true,
-    skipUserAccountsRpcCalls: true
-  };
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  const response = await fetchWithRetry(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Jupiter swap instructions error: ${data.error}`);
-  }
-  return data;
-}
-function parseSwapRemainingAccounts(swapInstruction) {
-  return swapInstruction.accounts.map((acc) => ({
-    pubkey: new import_web38.PublicKey(acc.pubkey),
-    isSigner: false,
-    // Always false for CPI — vault PDA signs via seeds
-    isWritable: acc.isWritable
-  }));
-}
-async function fetchAddressLookupTables(connection, addresses) {
-  if (addresses.length === 0) {
-    return [];
-  }
-  const pubkeys = addresses.map((addr) => new import_web38.PublicKey(addr));
-  const accountInfos = await connection.getMultipleAccountsInfo(pubkeys);
-  const tables = [];
-  for (let i = 0; i < accountInfos.length; i++) {
-    const info = accountInfos[i];
-    if (info === null) {
-      console.warn(`ALT not found: ${addresses[i]}`);
-      continue;
-    }
-    const table = new import_web38.AddressLookupTableAccount({
-      key: pubkeys[i],
-      state: import_web38.AddressLookupTableAccount.deserialize(info.data)
-    });
-    tables.push(table);
-  }
-  return tables;
-}
-async function buildSwapData(connection, inputMint, outputMint, amount, userPubkey, slippageBps = 50, maxAccounts = 40, apiKey) {
-  const quote = await getJupiterQuote(
-    inputMint,
-    outputMint,
-    amount,
-    slippageBps,
-    maxAccounts,
-    apiKey
-  );
-  const instructions = await getJupiterSwapInstructions(quote, userPubkey, apiKey);
-  const remainingAccounts = parseSwapRemainingAccounts(instructions.swapInstruction);
-  const addressLookupTables = await fetchAddressLookupTables(
-    connection,
-    instructions.addressLookupTableAddresses
-  );
-  return {
-    quote,
-    instructions,
-    remainingAccounts,
-    addressLookupTables
-  };
-}
-
-// src/jupiter/price.ts
-var import_anchor5 = require("@coral-xyz/anchor");
-async function fetchJupiterPriceUsd(mint, apiKey) {
-  const url = `https://api.jup.ag/price/v3?ids=${mint}`;
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "x-api-key": apiKey
-      }
-    });
-    if (!response.ok) {
-      console.warn(`Jupiter Price API error: ${response.status}`);
-      return null;
-    }
-    const data = await response.json();
-    const priceData = data[mint];
-    if (!priceData?.usdPrice) {
-      console.warn(`No price data for ${mint}`);
-      return null;
-    }
-    return priceData.usdPrice;
-  } catch (error) {
-    console.warn(`Failed to fetch Jupiter price: ${error.message}`);
-    return null;
-  }
-}
-async function fetchJlpRate(jlpMint, fallbackPrice = 4.6, apiKey) {
-  const priceUsd = await fetchJupiterPriceUsd(jlpMint, apiKey);
-  if (priceUsd === null) {
-    console.warn(`Using fallback JLP price: $${fallbackPrice}`);
-    return new import_anchor5.BN(Math.round(fallbackPrice * 1e8));
-  }
-  console.log(`JLP price: $${priceUsd.toFixed(4)} -> ${Math.round(priceUsd * 1e8)} (8 decimals)`);
-  return new import_anchor5.BN(Math.round(priceUsd * 1e8));
-}
-
-// src/instructions/admin.ts
-async function createInitOrUpdateVaultInstruction(program, params, accounts) {
-  return await program.methods.initOrUpdateJlpVault({
-    jlpMint: params.jlpMint,
-    baseAssetMints: params.baseAssetMints,
-    jlxAssetMints: params.jlxAssetMints,
-    newAdmin: params.newAdmin,
-    manager: params.manager,
-    feeReceiver: params.feeReceiver,
-    flags: params.flags,
-    jlpSlippageBps: params.jlpSlippageBps,
-    oracleStalenessThreshold: params.oracleStalenessThreshold
-  }).accounts({
-    admin: accounts.admin
-  }).instruction();
-}
-async function createInitializeStvInstruction(program, params, accounts) {
-  return await program.methods.initializeStv({
-    mgmtFeeBps: params.mgmtFeeBps,
-    perfFeeBps: params.perfFeeBps,
-    maxDeposit: params.maxDeposit,
-    minDeposit: params.minDeposit
-  }).accounts({
-    admin: accounts.admin,
-    jlpVault: accounts.jlpVault,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    tokenProgram: accounts.tokenProgram
-  }).instruction();
-}
-async function createUpdateStvInstruction(program, params, accounts) {
-  return await program.methods.updateStv({
-    mgmtFeeBps: params.mgmtFeeBps,
-    perfFeeBps: params.perfFeeBps,
-    flags: params.flags,
-    maxDeposit: params.maxDeposit,
-    minDeposit: params.minDeposit,
-    jlMint: params.jlMint,
-    pps: params.pps,
-    hwm: params.hwm,
-    baseLoaned: params.baseLoaned
-  }).accounts({
-    admin: accounts.admin,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv
-  }).instruction();
-}
-
-// src/instructions/user.ts
-async function createDepositInstruction(program, amount, accounts, remainingAccounts = []) {
-  return await program.methods.deposit(amount).accounts({
-    user: accounts.user,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    userBaseAta: accounts.userBaseAta,
-    userJvxAta: accounts.userJvxAta,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createWithdrawInstruction(program, sharesToBurn, accounts, remainingAccounts = []) {
-  return await program.methods.withdraw(sharesToBurn).accounts({
-    user: accounts.user,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    userBaseAta: accounts.userBaseAta,
-    userJvxAta: accounts.userJvxAta,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-
-// src/instructions/manager.ts
-function toAnchorJupEarnDirection(dir) {
-  return dir === "Deposit" ? { deposit: {} } : { withdraw: {} };
-}
-function toAnchorMoveDirection(dir) {
-  return dir === "ToVault" ? { toVault: {} } : { fromVault: {} };
-}
-function toAnchorSwapDirection(dir) {
-  return dir === "JlxToJlp" ? { jlxToJlp: {} } : { jlpToJlx: {} };
-}
-async function createJupEarnInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.jupEarnDepositWithdraw({
-    direction: toAnchorJupEarnDirection(params.direction),
-    amount: params.amount
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createMoveJlxInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.moveStvToFromVault({
-    amountJlx: params.amountJlx,
-    direction: toAnchorMoveDirection(params.direction)
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    stvJlxAta: accounts.stvJlxAta,
-    vaultStagingAta: accounts.vaultStagingAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createSwapJlxJlpInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.swapJlxToFromJlp({
-    stvIndex: params.stvIndex,
-    direction: toAnchorSwapDirection(params.direction),
-    amountIn: params.amountIn,
-    expectedAmountOut: params.expectedAmountOut,
-    jupiterData: params.jupiterData
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    vaultJlxAta: accounts.vaultJlxAta,
-    vaultJlpAta: accounts.vaultJlpAta,
-    jlpMint: accounts.jlpMint,
-    tokenProgram: accounts.tokenProgram,
-    jupiterProgram: accounts.jupiterProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createSettleYieldInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.settleYield().accounts({
-    jlpVault: accounts.jlpVault,
-    vaultJlpAta: accounts.vaultJlpAta,
-    stv0: accounts.stvBtc,
-    stv1: accounts.stvEth,
-    stv2: accounts.stvSol,
-    stv3: accounts.stvUsdc,
-    stv4: accounts.stvJupusd,
-    stagingJlx0: accounts.stagingBtc,
-    stagingJlx1: accounts.stagingEth,
-    stagingJlx2: accounts.stagingSol,
-    stagingJlx3: accounts.stagingUsdc,
-    stagingJlx4: accounts.stagingJupusd,
-    dovesBtcUsd: accounts.oracleBtc,
-    dovesEthUsd: accounts.oracleEth,
-    dovesSolUsd: accounts.oracleSol,
-    jlpPool: accounts.jlpPool,
-    jlpMintAccount: accounts.jlpMintAccount,
-    manager: accounts.manager
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-
-// src/instructions/fees.ts
-async function createClaimFeesInstruction(program, accounts, remainingAccounts = []) {
-  return await program.methods.claimFees().accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
-    feeReceiverJlxAta: accounts.feeReceiverJlxAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-
-// src/client.ts
-var JlpdClientError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "JlpdClientError";
-  }
-};
-var JlpdClient = class _JlpdClient {
-  constructor(connection, programId = JLPD_PROGRAM_ID, options) {
-    // Cache for PoolContext instances (avoids re-deriving PDAs/ATAs)
-    this.poolContextCache = /* @__PURE__ */ new Map();
-    this.connection = connection;
-    this.programId = programId;
-    const [vaultPda, vaultBump] = deriveVaultPda(programId);
-    this.vaultPda = vaultPda;
-    this.vaultBump = vaultBump;
-    this.program = createProgram(connection);
-    this.jupiterApiKey = options?.jupiterApiKey;
-  }
-  static mainnet(connection, options) {
-    return new _JlpdClient(connection, JLPD_PROGRAM_ID, options);
-  }
-  static devnet(connection, options) {
-    const devnetProgramId = new import_web39.PublicKey(
-      "AcVcAihjB9Z3Lg3ZiboWxni2sTzXUrrsF3unGX4ntn6p"
-    );
-    return new _JlpdClient(connection, devnetProgramId, options);
-  }
-  // Fetch vault account
-  async fetchVault() {
-    const accountInfo = await this.connection.getAccountInfo(this.vaultPda);
-    if (!accountInfo) return null;
-    return parseVault(accountInfo.data);
-  }
-  // Fetch STV by base mint
-  async fetchStv(baseMint) {
-    const [stvPda] = deriveStvPda(baseMint, this.programId);
-    const accountInfo = await this.connection.getAccountInfo(stvPda);
-    if (!accountInfo) return null;
-    return parseStv(accountInfo.data);
-  }
-  // Fetch exchange rate for a pool
-  async fetchExchangeRate(poolName) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    if (!pool.hasJupiterLend) {
-      return {
-        rate: 1,
-        rawRate: BigInt(EXCHANGE_RATE_PRECISION),
-        storedRate: 1,
-        staleness: 0,
-        isFresh: true
-      };
-    }
-    const accounts = await this.connection.getMultipleAccountsInfo([
-      pool.lending,
-      pool.rewardsRateModel,
-      pool.fTokenMint
-    ]);
-    const [lendingInfo, rewardsInfo, mintInfo] = accounts;
-    if (!lendingInfo || !rewardsInfo || !mintInfo) {
-      throw new JlpdClientError("Failed to fetch Jupiter Lend accounts");
-    }
-    const lendingData = parseLendingAccount(lendingInfo.data);
-    const rewardsData = parseRewardsRateModel(rewardsInfo.data);
-    const slot = await this.connection.getSlot();
-    const timestamp = await this.connection.getBlockTime(slot);
-    if (!timestamp) throw new JlpdClientError("Failed to get block time");
-    const supply = mintInfo.data.readBigUInt64LE(36);
-    const rawRate = calculateExchangeRate(
-      lendingData.tokenExchangePrice,
-      rewardsData.yearlyReward,
-      BigInt(timestamp),
-      lendingData.lastUpdateTimestamp,
-      supply
-    );
-    const rate = Number(rawRate) / EXCHANGE_RATE_PRECISION;
-    const storedRate = Number(lendingData.tokenExchangePrice) / EXCHANGE_RATE_PRECISION;
-    const staleness = timestamp - Number(lendingData.lastUpdateTimestamp);
-    return {
-      rate,
-      rawRate,
-      storedRate,
-      staleness,
-      isFresh: staleness < 300
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
     };
-  }
-  /**
-   * Calculate APY based on PPS growth over time
-   *
-   * @param poolName Pool to calculate APY for
-   * @param startPps PPS at the start of the period (as BN with 9 decimals)
-   * @param startTime Unix timestamp (seconds) when startPps was recorded
-   * @returns APY as a decimal (e.g., 0.12 = 12% APY)
-   *
-   * @example
-   * ```typescript
-   * // Calculate APY from a week ago
-   * const startPps = new BN("1050000000"); // 1.05 (9 decimals)
-   * const startTime = Math.floor(Date.now() / 1000) - 7 * 24 * 60 * 60;
-   * const apy = await client.calculateApy("SOL", startPps, startTime);
-   * console.log(`APY: ${(apy * 100).toFixed(2)}%`);
-   * ```
-   */
-  async calculateApy(poolName, startPps, startTime) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    const [stv, slot] = await Promise.all([
-      this.fetchStv(pool.mint),
-      this.connection.getSlot()
-    ]);
-    if (!stv) throw new JlpdClientError(`STV not found for pool: ${poolName}`);
-    const currentTime = await this.connection.getBlockTime(slot);
-    if (!currentTime) throw new JlpdClientError("Failed to get block time");
-    const currentPps = stv.pps;
-    const startPpsNum = Number(startPps.toString()) / PPS_DECIMALS;
-    const currentPpsNum = Number(currentPps.toString()) / PPS_DECIMALS;
-    const timeElapsed = currentTime - startTime;
-    if (timeElapsed <= 0) {
-      throw new JlpdClientError("Start time must be in the past");
-    }
-    const SECONDS_PER_YEAR2 = 365.25 * 24 * 60 * 60;
-    const ppsGrowthRatio = currentPpsNum / startPpsNum;
-    if (ppsGrowthRatio <= 0) {
-      return -1;
-    }
-    const annualizationFactor = SECONDS_PER_YEAR2 / timeElapsed;
-    const apy = Math.pow(ppsGrowthRatio, annualizationFactor) - 1;
-    return apy;
-  }
-  /**
-   * Calculate simple APY (non-compounded) based on PPS growth
-   *
-   * @param poolName Pool to calculate APY for
-   * @param startPps PPS at the start of the period
-   * @param startTime Unix timestamp when startPps was recorded
-   * @returns Simple APY as a decimal
-   */
-  async calculateSimpleApy(poolName, startPps, startTime) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    const [stv, slot] = await Promise.all([
-      this.fetchStv(pool.mint),
-      this.connection.getSlot()
-    ]);
-    if (!stv) throw new JlpdClientError(`STV not found for pool: ${poolName}`);
-    const currentTime = await this.connection.getBlockTime(slot);
-    if (!currentTime) throw new JlpdClientError("Failed to get block time");
-    const startPpsNum = Number(startPps.toString()) / PPS_DECIMALS;
-    const currentPpsNum = Number(stv.pps.toString()) / PPS_DECIMALS;
-    const timeElapsed = currentTime - startTime;
-    if (timeElapsed <= 0) {
-      throw new JlpdClientError("Start time must be in the past");
-    }
-    const SECONDS_PER_YEAR2 = 365.25 * 24 * 60 * 60;
-    const growthRate = (currentPpsNum - startPpsNum) / startPpsNum;
-    const simpleApy = growthRate * (SECONDS_PER_YEAR2 / timeElapsed);
-    return simpleApy;
-  }
-  // Get pool context for pool-specific operations (cached)
-  pool(poolNameOrMint) {
-    const key = typeof poolNameOrMint === "string" ? poolNameOrMint : poolNameOrMint.toBase58();
-    let ctx = this.poolContextCache.get(key);
-    if (!ctx) {
-      const pool = typeof poolNameOrMint === "string" ? getPoolByName(poolNameOrMint) : getPoolByMint(poolNameOrMint);
-      if (!pool) throw new JlpdClientError(`Unknown pool: ${key}`);
-      ctx = new PoolContext(this, pool);
-      this.poolContextCache.set(key, ctx);
-      if (typeof poolNameOrMint === "string") {
-        this.poolContextCache.set(pool.mint.toBase58(), ctx);
-      } else {
-        this.poolContextCache.set(pool.name, ctx);
-      }
-    }
-    return ctx;
-  }
-  // Get swap context for swap operations
-  swap() {
-    return new SwapContext(this);
-  }
-  // Get admin context for admin operations
-  admin() {
-    return new AdminContext(this);
-  }
-  // Build a versioned transaction
-  async buildTransaction(payer, ixs, alts = []) {
-    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
-    const message = new import_web39.TransactionMessage({
-      payerKey: payer,
-      recentBlockhash: blockhash,
-      instructions: ixs
-    }).compileToV0Message(alts);
-    return new import_web39.VersionedTransaction(message);
-  }
-};
-var PoolContext = class {
-  constructor(client, pool) {
-    this.client = client;
-    this.pool = pool;
-    const [pda, bump] = deriveStvPda(pool.mint, client.programId);
-    this.stvPda = pda;
-    this.stvBump = bump;
-    const vaultAtas = deriveVaultAtas(pool.fTokenMint, MINTS.JLP, client.vaultPda);
-    this.vaultStagingAta = vaultAtas.stagingAta;
-    this.vaultJlpAta = vaultAtas.jlpAta;
-    this.vaultBaseAta = deriveAta(pool.mint, client.vaultPda, true);
-    const stvAtas = deriveStvAtas(pool.mint, pool.fTokenMint, this.stvPda);
-    this.stvBaseAta = stvAtas.baseAta;
-    this.stvJlxAta = stvAtas.jlxAta;
-  }
-  // Deposit base asset and receive jvX shares
-  async deposit(params) {
-    if (params.amount.isZero() || params.amount.isNeg()) {
-      throw new JlpdClientError("Deposit amount must be positive");
-    }
-    const [stv, { blockhash }] = await Promise.all([
-      this.client.fetchStv(this.pool.mint),
-      this.client.connection.getLatestBlockhash("confirmed")
-    ]);
-    if (!stv) throw new JlpdClientError("STV not found");
-    const userAtas = deriveUserAtas(this.pool.mint, stv.jvMint, params.user);
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createDepositInstruction(
-      this.client.program,
-      params.amount,
-      {
-        user: params.user,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        jvMint: stv.jvMint,
-        userBaseAta: userAtas.baseAta,
-        userJvxAta: userAtas.jvxAta,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    const message = new import_web39.TransactionMessage({
-      payerKey: params.user,
-      recentBlockhash: blockhash,
-      instructions: [ix]
-    }).compileToV0Message();
-    return new import_web39.VersionedTransaction(message);
-  }
-  // Burn jvX shares and withdraw base asset
-  async withdraw(params) {
-    if (params.shares.isZero() || params.shares.isNeg()) {
-      throw new JlpdClientError("Withdraw shares must be positive");
-    }
-    const [stv, { blockhash }] = await Promise.all([
-      this.client.fetchStv(this.pool.mint),
-      this.client.connection.getLatestBlockhash("confirmed")
-    ]);
-    if (!stv) throw new JlpdClientError("STV not found");
-    const userAtas = deriveUserAtas(this.pool.mint, stv.jvMint, params.user);
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createWithdrawInstruction(
-      this.client.program,
-      params.shares,
-      {
-        user: params.user,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        jvMint: stv.jvMint,
-        userBaseAta: userAtas.baseAta,
-        userJvxAta: userAtas.jvxAta,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    const message = new import_web39.TransactionMessage({
-      payerKey: params.user,
-      recentBlockhash: blockhash,
-      instructions: [ix]
-    }).compileToV0Message();
-    return new import_web39.VersionedTransaction(message);
-  }
-  // Jupiter Earn deposit/withdraw
-  async jupEarn(params) {
-    if (!this.pool.hasJupiterLend) {
-      throw new JlpdClientError(`Pool ${this.pool.name} does not support Jupiter Earn`);
-    }
-    const remainingAccounts = params.direction === "Deposit" ? buildJupEarnDepositAccounts(this.pool, this.stvPda, this.stvBaseAta, this.stvJlxAta) : buildJupEarnWithdrawAccounts(this.pool, this.stvPda, this.stvJlxAta, this.stvBaseAta);
-    const ix = await createJupEarnInstruction(
-      this.client.program,
-      { direction: params.direction, amount: params.amount },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta
-      },
-      remainingAccounts
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Move jlX between STV and vault
-  async moveJlx(params) {
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createMoveJlxInstruction(
-      this.client.program,
-      { amountJlx: params.jlxAmount, direction: params.direction },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        stvJlxAta: this.stvJlxAta,
-        vaultStagingAta: this.vaultStagingAta,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Claim fees
-  async claimFees(params) {
-    const [vault, stv] = await Promise.all([
-      this.client.fetchVault(),
-      this.client.fetchStv(this.pool.mint)
-    ]);
-    if (!vault) throw new JlpdClientError("Vault not found");
-    if (!stv) throw new JlpdClientError("STV not found");
-    const feeReceiverJlxAta = (0, import_spl_token5.getAssociatedTokenAddressSync)(
-      this.pool.fTokenMint,
-      vault.feeReceiver,
-      true
-    );
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createClaimFeesInstruction(
-      this.client.program,
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        jvMint: stv.jvMint,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta,
-        feeReceiverJlxAta,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Update STV parameters (admin only)
-  async updateStv(params) {
-    const stv = await this.client.fetchStv(this.pool.mint);
-    if (!stv) throw new JlpdClientError("STV not found");
-    const ix = await createUpdateStvInstruction(
-      this.client.program,
-      {
-        mgmtFeeBps: params.mgmtFeeBps ?? stv.mgmtFeeBps,
-        perfFeeBps: params.perfFeeBps ?? stv.perfFeeBps,
-        flags: params.flags ?? stv.flags,
-        maxDeposit: params.maxDeposit ?? stv.maxDeposit,
-        minDeposit: params.minDeposit ?? stv.minDeposit,
-        jlMint: params.jlMint ?? null,
-        pps: params.pps ?? null,
-        hwm: params.hwm ?? null,
-        baseLoaned: params.baseLoaned ?? null
-      },
-      {
-        admin: params.admin,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda
-      }
-    );
-    return this.client.buildTransaction(params.admin, [ix]);
-  }
-};
-var SwapContext = class {
-  constructor(client) {
-    this.client = client;
-  }
-  // Get a quote for jlX <-> JLP swap
-  async quoteJlxJlp(params) {
-    const poolConfig = getPoolByName(params.pool);
-    if (!poolConfig) throw new JlpdClientError(`Unknown pool: ${params.pool}`);
-    const swapMint = poolConfig.jupDirectSwap ? poolConfig.fTokenMint : poolConfig.mint;
-    const inputMint = params.direction === "JlxToJlp" ? swapMint : MINTS.JLP;
-    const outputMint = params.direction === "JlxToJlp" ? MINTS.JLP : swapMint;
-    const quote = await getJupiterQuote(
-      inputMint,
-      outputMint,
-      BigInt(params.amountIn.toString()),
-      params.slippageBps ?? 30,
-      40,
-      this.client.jupiterApiKey
-    );
-    const swapIxs = await getJupiterSwapInstructions(quote, this.client.vaultPda, this.client.jupiterApiKey);
-    const remainingAccounts = parseSwapRemainingAccounts(swapIxs.swapInstruction);
-    const alts = await fetchAddressLookupTables(
-      this.client.connection,
-      swapIxs.addressLookupTableAddresses
-    );
-    return {
-      inputMint,
-      outputMint,
-      inAmount: new import_anchor6.BN(quote.inAmount),
-      outAmount: new import_anchor6.BN(quote.outAmount),
-      minOutAmount: new import_anchor6.BN(quote.otherAmountThreshold),
-      priceImpactPct: parseFloat(quote.priceImpactPct),
-      route: quote.routePlan.map((r) => r.swapInfo.label || "unknown"),
-      jupiterData: Buffer.from(swapIxs.swapInstruction.data, "base64"),
-      remainingAccounts,
-      addressLookupTables: alts,
-      computeUnitLimit: swapIxs.computeUnitLimit ?? 6e5
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
     };
-  }
-  // Build jlX <-> JLP swap transaction
-  async swapJlxJlp(params) {
-    const poolConfig = getPoolByName(params.pool);
-    if (!poolConfig) throw new JlpdClientError(`Unknown pool: ${params.pool}`);
-    const poolCtx = this.client.pool(params.pool);
-    const computeIx = import_web39.ComputeBudgetProgram.setComputeUnitLimit({
-      units: params.quote.computeUnitLimit
-    });
-    const jupiterProgram = JUPITER_SWAP_PROGRAM_ID;
-    const swapIx = await createSwapJlxJlpInstruction(
-      this.client.program,
-      {
-        stvIndex: poolConfig.stvIndex,
-        direction: params.direction,
-        amountIn: params.amountIn,
-        expectedAmountOut: params.expectedOut,
-        jupiterData: params.quote.jupiterData
-      },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        vaultJlxAta: poolConfig.jupDirectSwap ? poolCtx.vaultStagingAta : poolCtx.vaultBaseAta,
-        vaultJlpAta: poolCtx.vaultJlpAta,
-        jlpMint: MINTS.JLP,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
-        jupiterProgram
-      },
-      params.quote.remainingAccounts
-    );
-    const { blockhash } = await this.client.connection.getLatestBlockhash("confirmed");
-    const message = new import_web39.TransactionMessage({
-      payerKey: params.manager,
-      recentBlockhash: blockhash,
-      instructions: [computeIx, swapIx]
-    }).compileToV0Message(params.quote.addressLookupTables);
-    return new import_web39.VersionedTransaction(message);
-  }
-};
-var AdminContext = class {
-  constructor(client) {
-    this.client = client;
-  }
-  // Initialize or update vault
-  async initOrUpdateVault(params) {
-    const currentVault = await this.client.fetchVault();
-    const ix = await createInitOrUpdateVaultInstruction(
-      this.client.program,
-      {
-        jlpMint: params.jlpMint ?? null,
-        baseAssetMints: params.baseAssetMints ?? null,
-        jlxAssetMints: params.jlxAssetMints ?? null,
-        newAdmin: params.newAdmin ?? null,
-        manager: params.manager ?? currentVault.manager,
-        feeReceiver: params.feeReceiver ?? currentVault.feeReceiver,
-        flags: params.flags ?? currentVault.flags,
-        jlpSlippageBps: params.jlpSlippageBps ?? currentVault.jlpSlippageBps,
-        oracleStalenessThreshold: params.oracleStalenessThreshold ?? null
-      },
-      {
-        admin: params.admin
-      }
-    );
-    return this.client.buildTransaction(params.admin, [ix]);
-  }
-  // Initialize STV
-  async initializeStv(params, jvMintKeypair) {
-    const pool = getPoolByName(params.poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${params.poolName}`);
-    const ix = await createInitializeStvInstruction(
-      this.client.program,
-      {
-        mgmtFeeBps: params.mgmtFeeBps,
-        perfFeeBps: params.perfFeeBps,
-        maxDeposit: params.maxDeposit,
-        minDeposit: params.minDeposit
-      },
-      {
-        admin: params.admin,
-        jlpVault: this.client.vaultPda,
-        baseMint: pool.mint,
-        jlMint: pool.fTokenMint,
-        jvMint: jvMintKeypair,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      }
-    );
-    return this.client.buildTransaction(params.admin, [ix]);
-  }
-  // Settle yield across all STVs
-  async settleYield(params) {
-    const poolNames = ["BTC", "ETH", "SOL", "USDC", "JupUSD"];
-    const pools = poolNames.map((name) => {
-      const pool = getPoolByName(name);
-      if (!pool) throw new JlpdClientError(`Unknown pool: ${name}`);
-      return pool;
-    });
-    const stvPdas = pools.map((p) => deriveStvPda(p.mint, this.client.programId)[0]);
-    const stagingAtas = pools.map(
-      (p) => (0, import_spl_token5.getAssociatedTokenAddressSync)(p.fTokenMint, this.client.vaultPda, true)
-    );
-    const lendingAccounts = pools.map((p) => ({
-      pubkey: p.hasJupiterLend ? p.lending : import_web39.PublicKey.default,
-      isSigner: false,
-      isWritable: false
-    }));
-    const rewardsAccounts = pools.map((p) => ({
-      pubkey: p.hasJupiterLend ? p.rewardsRateModel : import_web39.PublicKey.default,
-      isSigner: false,
-      isWritable: false
-    }));
-    const mintAccounts = pools.map((p) => ({
-      pubkey: p.fTokenMint,
-      isSigner: false,
-      isWritable: false
-    }));
-    const remainingAccounts = [...lendingAccounts, ...rewardsAccounts, ...mintAccounts];
-    const ix = await createSettleYieldInstruction(
-      this.client.program,
-      {},
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        vaultJlpAta: (0, import_spl_token5.getAssociatedTokenAddressSync)(MINTS.JLP, this.client.vaultPda, true),
-        jlpMint: MINTS.JLP,
-        stvBtc: stvPdas[0],
-        stvEth: stvPdas[1],
-        stvSol: stvPdas[2],
-        stvUsdc: stvPdas[3],
-        stvJupusd: stvPdas[4],
-        stagingBtc: stagingAtas[0],
-        stagingEth: stagingAtas[1],
-        stagingSol: stagingAtas[2],
-        stagingUsdc: stagingAtas[3],
-        stagingJupusd: stagingAtas[4],
-        oracleBtc: ORACLES.DOVES_BTC_USD,
-        oracleEth: ORACLES.DOVES_ETH_USD,
-        oracleSol: ORACLES.DOVES_SOL_USD,
-        jlpPool: JLP_POOL_PUBKEY,
-        jlpMintAccount: MINTS.JLP
-      },
-      remainingAccounts
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AdminContext,
-  EXCHANGE_RATE_PRECISION,
-  FLAG_DEPOSITS_DISABLED,
-  FLAG_JLP_DISABLED,
-  FLAG_PAUSED,
-  FLAG_REBALANCE_DISABLED,
-  FLAG_WITHDRAWALS_DISABLED,
-  JLPD_PROGRAM_ID,
-  JLP_POOL_PUBKEY,
-  JLP_VAULT_ACCOUNT_SIZE,
-  JLP_VAULT_DATA_SIZE,
-  JLP_VAULT_DISCRIMINATOR,
-  JUPITER_LEND_PROGRAM_ID,
-  JUPITER_PERPS_PROGRAM_ID,
-  JUPITER_SWAP_PROGRAM_ID,
-  JUPUSD_POOL,
-  JUP_LEND_PROGRAM_ID,
-  JlpdClient,
-  JlpdClientError,
-  LENDING_ADMIN,
-  LIQUIDITY_PROGRAM_ID,
-  LIQUIDITY_SINGLETON,
-  MINTS,
-  ORACLES,
-  POOLS,
-  PPS_DECIMALS,
-  PoolContext,
-  SEED_JLP_VAULT,
-  SEED_STV,
-  STV_ACCOUNT_SIZE,
-  STV_DATA_SIZE,
-  STV_DISCRIMINATOR,
-  STV_INDEX,
-  SwapContext,
-  USDC_POOL,
-  WBTC_POOL,
-  WETH_POOL,
-  WSOL_POOL,
-  baseToJlx,
-  baseToShares,
-  buildExchangeRateAccounts,
-  buildJupEarnDepositAccounts,
-  buildJupEarnWithdrawAccounts,
-  buildSwapData,
-  calculateExchangeRate,
-  calculateNav,
-  calculatePps,
-  clearAtaCache,
-  clearPdaCache,
-  createClaimFeesInstruction,
-  createDepositInstruction,
-  createInitOrUpdateVaultInstruction,
-  createInitializeStvInstruction,
-  createJupEarnInstruction,
-  createMoveJlxInstruction,
-  createProgram,
-  createSettleYieldInstruction,
-  createSwapJlxJlpInstruction,
-  createUpdateStvInstruction,
-  createWithdrawInstruction,
-  deriveAta,
-  deriveStvAtas,
-  deriveStvPda,
-  deriveUserAtas,
-  deriveVaultAtas,
-  deriveVaultPda,
-  fetchAddressLookupTables,
-  fetchJlpRate,
-  fetchJupiterPriceUsd,
-  getJupiterQuote,
-  getJupiterSwapInstructions,
-  getPoolByMint,
-  getPoolByName,
-  jlxToBase,
-  parseLendingAccount,
-  parseRewardsRateModel,
-  parseStv,
-  parseSwapRemainingAccounts,
-  parseVault,
-  sharesToBase
-});
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jlpdStrategy = exports.elementalLendV2 = exports.elementalLend = exports.pStvCore = exports.common = void 0;
+exports.common = __importStar(require("./common"));
+exports.pStvCore = __importStar(require("./p-stv-core"));
+exports.elementalLend = __importStar(require("./elemental-lend"));
+exports.elementalLendV2 = __importStar(require("./elemental-lend-v2"));
+exports.jlpdStrategy = __importStar(require("./jlpd-strategy"));