@elmntl/jlpd-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1843 @@
+"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_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_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,
+  createSettleYieldInstruction: () => createSettleYieldInstruction,
+  createSwapJlxJlpInstruction: () => createSwapJlxJlpInstruction,
+  createSwapJlxJlxInstruction: () => createSwapJlxJlxInstruction,
+  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
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_web312 = require("@solana/web3.js");
+var import_anchor5 = require("@coral-xyz/anchor");
+var import_spl_token5 = require("@solana/spl-token");
+
+// src/constants.ts
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+var JLPD_PROGRAM_ID = new import_web3.PublicKey(
+  "ELEM2bAobpZNuysfhyF28XGVjA1aTUwm6rPYyv1JX3oq"
+);
+var JUPITER_LEND_PROGRAM_ID = new import_web3.PublicKey(
+  "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"
+);
+var JUPITER_SWAP_PROGRAM_ID = new import_web3.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_web3.PublicKey("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4"),
+  WSOL: import_spl_token.NATIVE_MINT,
+  USDC: new import_web3.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+  WBTC: new import_web3.PublicKey("3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"),
+  WETH: new import_web3.PublicKey("7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"),
+  JupUSD: new import_web3.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_web3.PublicKey("4HBbPx9QJdjJ7GUe6bsiJjGybvfpDhQMMPXP1UEa7VT5"),
+  DOVES_ETH_USD: new import_web3.PublicKey("5URYohbPy32nxK1t3jAHVNfdWY2xTubHiFvLrE3VhXEp"),
+  DOVES_SOL_USD: new import_web3.PublicKey("39cWjvHrpHNz2SbXv6ME4NPhqBDBd4KsjUYv5JkHEAJU"),
+  // Pyth oracle for JLP price
+  PYTH_JLP_USD: new import_web3.PublicKey("2TTGSRSezqFzeLUH8JwRUbtN66XLLaymfYsWRTMjfiMw")
+};
+
+// src/accounts/pdas.ts
+var import_web32 = 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_web32.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_web32.PublicKey.findProgramAddressSync(
+      [SEED_STV_BUFFER, baseMint.toBuffer()],
+      programId
+    );
+    pdaCache.set(key, cached);
+  }
+  return cached;
+}
+function clearPdaCache() {
+  pdaCache.clear();
+}
+
+// src/accounts/vault.ts
+var import_web33 = require("@solana/web3.js");
+var import_anchor = 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_web33.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const manager = new import_web33.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const feeReceiver = new import_web33.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const jlpMint = new import_web33.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const baseAssetMints = [];
+  for (let i = 0; i < 5; i++) {
+    baseAssetMints.push(new import_web33.PublicKey(data.subarray(offset, offset + 32)));
+    offset += 32;
+  }
+  const jlxAssetMints = [];
+  for (let i = 0; i < 5; i++) {
+    jlxAssetMints.push(new import_web33.PublicKey(data.subarray(offset, offset + 32)));
+    offset += 32;
+  }
+  const oracleStalenessThreshold = new import_anchor.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_web34 = require("@solana/web3.js");
+var import_anchor2 = 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_web34.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const jlMint = new import_web34.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const jvMint = new import_web34.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const pps = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const hwm = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const lastMgmtFeeTs = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const baseLoaned = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const accruedFeesJlx = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const maxDeposit = new import_anchor2.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const minDeposit = new import_anchor2.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_anchor3 = require("@coral-xyz/anchor");
+var PPS_DECIMALS_BN = new import_anchor3.BN(PPS_DECIMALS);
+var EXCHANGE_RATE_PRECISION_BN = new import_anchor3.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_anchor3.BN(exchangeRate.toString())).div(EXCHANGE_RATE_PRECISION_BN);
+  return stvBaseBalance.add(jlxValue).add(baseLoaned);
+}
+function calculatePps(nav, jvSupply) {
+  if (jvSupply.isZero()) {
+    return new import_anchor3.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_web35 = require("@solana/web3.js");
+var import_spl_token3 = require("@solana/spl-token");
+var LENDING_ADMIN = new import_web35.PublicKey("5nmGjA4s7ATzpBQXC5RNceRpaJ7pYw2wKsNBWyuSAZV6");
+var LIQUIDITY_PROGRAM_ID = new import_web35.PublicKey("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC");
+var LIQUIDITY_SINGLETON = new import_web35.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z");
+var WSOL_POOL = {
+  mint: import_spl_token3.NATIVE_MINT,
+  name: "SOL",
+  lending: new import_web35.PublicKey("BeAqbxfrcXmzEYT2Ra62oW2MqkuFDHaCtps47Mzg6Zj3"),
+  fTokenMint: new import_web35.PublicKey("2uQsyo1fXXQkDtcpXnLofWy88PxcvnfH2L8FPSE62FVU"),
+  tokenReservesLiquidity: new import_web35.PublicKey("4Y66HtUEqbbbpZdENGtFdVhUMS3tnagffn3M4do59Nfy"),
+  supplyPositionOnLiquidity: new import_web35.PublicKey("4SkEYxmiRgQ4VYyvh9VB4k39M49BpqazyzDUFDzJhXQm"),
+  rewardsRateModel: new import_web35.PublicKey("CkeQGDRsgMZcCaU8cZEdC2aFAohia4jLzL36RaLcUDsR"),
+  vault: new import_web35.PublicKey("BWeWnEbVmYKLmUpcrAXGrvDYxVA7VBS6TEnNc74jTerw"),
+  rateModel: new import_web35.PublicKey("Acvyi9HBGmqh3Exe1N4PjBVyY8fokq2AdC6fSLqV6KSo"),
+  claimAccount: new import_web35.PublicKey("6AQGR8zK4KTVZfZ9UZaRzyEL5ynvwVaF5ywVdmtJT24N"),
+  decimals: 9,
+  stvIndex: 2 /* SOL */,
+  hasJupiterLend: true
+};
+var USDC_POOL = {
+  mint: MINTS.USDC,
+  name: "USDC",
+  lending: new import_web35.PublicKey("2vVYHYM8VYnvZqQWpTJSj8o8DBf1wM8pVs3bsTgYZiqJ"),
+  fTokenMint: new import_web35.PublicKey("9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D"),
+  tokenReservesLiquidity: new import_web35.PublicKey("94vK29npVbyRHXH63rRcTiSr26SFhrQTzbpNJuhQEDu"),
+  supplyPositionOnLiquidity: new import_web35.PublicKey("Hf9gtkM4dpVBahVSzEXSVCAPpKzBsBcns3s8As3z77oF"),
+  rewardsRateModel: new import_web35.PublicKey("5xSPBiD3TibamAnwHDhZABdB4z4F9dcj5PnbteroBTTd"),
+  vault: new import_web35.PublicKey("BmkUoKMFYBxNSzWXyUjyMJjMAaVz4d8ZnxwwmhDCUXFB"),
+  rateModel: new import_web35.PublicKey("5pjzT5dFTsXcwixoab1QDLvZQvpYJxJeBphkyfHGn688"),
+  claimAccount: new import_web35.PublicKey("HN1r4VfkDn53xQQfeGDYrNuDKFdemAhZsHYRwBrFhsW"),
+  decimals: 6,
+  stvIndex: 3 /* USDC */,
+  hasJupiterLend: true
+};
+var JUPUSD_POOL = {
+  mint: MINTS.JupUSD,
+  name: "JupUSD",
+  lending: new import_web35.PublicKey("papYEgeG5uPE4niUWZhihUUzVVotJn1mAWbYo2UBSHi"),
+  fTokenMint: new import_web35.PublicKey("7GxATsNMnaC88vdwd2t3mwrFuQwwGvmYPrUQ4D6FotXk"),
+  tokenReservesLiquidity: new import_web35.PublicKey("2tQE8jVR5ezDw3PDa21BNzfyQ14Ug5cTf6n3swJNjkod"),
+  supplyPositionOnLiquidity: new import_web35.PublicKey("DXFoJruECdEch2KpzLQ2cSpxoBSsyg4bpYPnHYofsbD4"),
+  rewardsRateModel: new import_web35.PublicKey("E3U32h49TL9Qof3NeLja9qJxTrGYpY1o1NQPtrSLJjcc"),
+  vault: new import_web35.PublicKey("9kGqd5zsQGaFfFPdUuEgbRM4V7x72Jdt7WTS4uRouAQ7"),
+  rateModel: new import_web35.PublicKey("2hT44GA9r5PiqsbbmqN5CuF7ymtquoEdokRncAs9CVej"),
+  claimAccount: new import_web35.PublicKey("6q9vTzAsTMEPUCwuhEdJSJdpRNXnubwKZbi2go1B8nvg"),
+  decimals: 6,
+  stvIndex: 4 /* JupUSD */,
+  hasJupiterLend: true
+};
+var WBTC_POOL = {
+  mint: MINTS.WBTC,
+  name: "BTC",
+  lending: import_web35.PublicKey.default,
+  fTokenMint: MINTS.WBTC,
+  // jlBTC = WBTC (base-only)
+  tokenReservesLiquidity: import_web35.PublicKey.default,
+  supplyPositionOnLiquidity: import_web35.PublicKey.default,
+  rewardsRateModel: import_web35.PublicKey.default,
+  vault: import_web35.PublicKey.default,
+  rateModel: import_web35.PublicKey.default,
+  claimAccount: import_web35.PublicKey.default,
+  decimals: 8,
+  stvIndex: 0 /* BTC */,
+  hasJupiterLend: false
+};
+var WETH_POOL = {
+  mint: MINTS.WETH,
+  name: "ETH",
+  lending: import_web35.PublicKey.default,
+  fTokenMint: MINTS.WETH,
+  // jlETH = WETH (base-only)
+  tokenReservesLiquidity: import_web35.PublicKey.default,
+  supplyPositionOnLiquidity: import_web35.PublicKey.default,
+  rewardsRateModel: import_web35.PublicKey.default,
+  vault: import_web35.PublicKey.default,
+  rateModel: import_web35.PublicKey.default,
+  claimAccount: import_web35.PublicKey.default,
+  decimals: 8,
+  stvIndex: 1 /* ETH */,
+  hasJupiterLend: false
+};
+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_web36 = require("@solana/web3.js");
+var import_spl_token4 = require("@solana/spl-token");
+var JUPITER_LEND_PROGRAM_ID2 = new import_web36.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_web36.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_web36.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: JUPITER_LEND_PROGRAM_ID2, isSigner: false, isWritable: false }
+  ];
+}
+function parseLendingAccount(data) {
+  return {
+    mint: new import_web36.PublicKey(data.slice(8, 40)),
+    fTokenMint: new import_web36.PublicKey(data.slice(40, 72)),
+    lendingId: data.readUInt16LE(72),
+    decimals: data[74],
+    rewardsRateModel: new import_web36.PublicKey(data.slice(75, 107)),
+    liquidityExchangePrice: data.readBigUInt64LE(107),
+    tokenExchangePrice: data.readBigUInt64LE(115),
+    lastUpdateTimestamp: data.readBigUInt64LE(123),
+    tokenReservesLiquidity: new import_web36.PublicKey(data.slice(131, 163)),
+    supplyPositionOnLiquidity: new import_web36.PublicKey(data.slice(163, 195)),
+    bump: data[195]
+  };
+}
+function parseRewardsRateModel(data) {
+  return {
+    mint: new import_web36.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_web37 = require("@solana/web3.js");
+var JUPITER_API_BASE = "https://lite-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) {
+  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 response = await fetchWithRetry(url);
+  const data = await response.json();
+  if (data.error) {
+    throw new Error(`Jupiter quote error: ${data.error}`);
+  }
+  return data;
+}
+async function getJupiterSwapInstructions(quote, userPubkey) {
+  const url = `${JUPITER_API_BASE}/swap-instructions`;
+  const body = {
+    quoteResponse: quote,
+    userPublicKey: userPubkey.toBase58(),
+    wrapAndUnwrapSol: true,
+    useSharedAccounts: true,
+    dynamicComputeUnitLimit: true,
+    skipUserAccountsRpcCalls: false
+  };
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    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_web37.PublicKey(acc.pubkey),
+    isSigner: acc.isSigner,
+    isWritable: acc.isWritable
+  }));
+}
+async function fetchAddressLookupTables(connection, addresses) {
+  if (addresses.length === 0) {
+    return [];
+  }
+  const pubkeys = addresses.map((addr) => new import_web37.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_web37.AddressLookupTableAccount({
+      key: pubkeys[i],
+      state: import_web37.AddressLookupTableAccount.deserialize(info.data)
+    });
+    tables.push(table);
+  }
+  return tables;
+}
+async function buildSwapData(connection, inputMint, outputMint, amount, userPubkey, slippageBps = 50, maxAccounts = 40) {
+  const quote = await getJupiterQuote(
+    inputMint,
+    outputMint,
+    amount,
+    slippageBps,
+    maxAccounts
+  );
+  const instructions = await getJupiterSwapInstructions(quote, userPubkey);
+  const remainingAccounts = parseSwapRemainingAccounts(instructions.swapInstruction);
+  const addressLookupTables = await fetchAddressLookupTables(
+    connection,
+    instructions.addressLookupTableAddresses
+  );
+  return {
+    quote,
+    instructions,
+    remainingAccounts,
+    addressLookupTables
+  };
+}
+
+// src/jupiter/price.ts
+var import_anchor4 = require("@coral-xyz/anchor");
+var DEFAULT_API_KEY = "9edc77aa-0be8-41cf-9264-907603c44150";
+async function fetchJupiterPriceUsd(mint, apiKey = DEFAULT_API_KEY) {
+  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 = DEFAULT_API_KEY) {
+  const priceUsd = await fetchJupiterPriceUsd(jlpMint, apiKey);
+  if (priceUsd === null) {
+    console.warn(`Using fallback JLP price: $${fallbackPrice}`);
+    return new import_anchor4.BN(Math.round(fallbackPrice * 1e8));
+  }
+  console.log(`JLP price: $${priceUsd.toFixed(4)} -> ${Math.round(priceUsd * 1e8)} (8 decimals)`);
+  return new import_anchor4.BN(Math.round(priceUsd * 1e8));
+}
+
+// src/instructions/admin.ts
+var import_web38 = require("@solana/web3.js");
+var INIT_OR_UPDATE_VAULT_DISCRIMINATOR = Buffer.from([
+  91,
+  101,
+  110,
+  100,
+  105,
+  110,
+  103,
+  93
+]);
+var INITIALIZE_STV_DISCRIMINATOR = Buffer.from([
+  105,
+  110,
+  105,
+  116,
+  95,
+  115,
+  116,
+  118
+]);
+var UPDATE_STV_DISCRIMINATOR = Buffer.from([
+  117,
+  112,
+  100,
+  95,
+  115,
+  116,
+  118,
+  0
+]);
+function serializeOptionPubkey(value) {
+  if (value === null) {
+    return Buffer.from([0]);
+  }
+  return Buffer.concat([Buffer.from([1]), value.toBuffer()]);
+}
+function serializeOptionU64(value) {
+  if (value === null) {
+    return Buffer.from([0]);
+  }
+  const buf = Buffer.alloc(9);
+  buf.writeUInt8(1, 0);
+  buf.writeBigUInt64LE(BigInt(value.toString()), 1);
+  return buf;
+}
+function serializeU16(value) {
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16LE(value, 0);
+  return buf;
+}
+function serializeU64(value) {
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(BigInt(value.toString()), 0);
+  return buf;
+}
+function createInitOrUpdateVaultInstruction(params, accounts, programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([
+    INIT_OR_UPDATE_VAULT_DISCRIMINATOR,
+    serializeOptionPubkey(params.jlpMint),
+    // baseAssetMints - Option<[Pubkey; 5]>
+    params.baseAssetMints ? Buffer.concat([Buffer.from([1]), ...params.baseAssetMints.map((p) => p.toBuffer())]) : Buffer.from([0]),
+    // jlxAssetMints - Option<[Pubkey; 5]>
+    params.jlxAssetMints ? Buffer.concat([Buffer.from([1]), ...params.jlxAssetMints.map((p) => p.toBuffer())]) : Buffer.from([0]),
+    serializeOptionPubkey(params.newAdmin),
+    serializeOptionPubkey(params.manager ?? null),
+    serializeOptionPubkey(params.feeReceiver ?? null),
+    params.flags !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU16(params.flags)]) : Buffer.from([0]),
+    params.jlpSlippageBps !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU16(params.jlpSlippageBps)]) : Buffer.from([0]),
+    serializeOptionU64(params.oracleStalenessThreshold)
+  ]);
+  const keys = [
+    { pubkey: accounts.admin, isSigner: true, isWritable: true },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false }
+  ];
+  return new import_web38.TransactionInstruction({ keys, programId, data });
+}
+function createInitializeStvInstruction(params, accounts, programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([
+    INITIALIZE_STV_DISCRIMINATOR,
+    serializeU16(params.mgmtFeeBps),
+    serializeU16(params.perfFeeBps),
+    serializeU64(params.maxDeposit),
+    serializeU64(params.minDeposit)
+  ]);
+  const keys = [
+    { pubkey: accounts.admin, isSigner: true, isWritable: true },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jvMint, isSigner: true, isWritable: true },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.associatedTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.rent, isSigner: false, isWritable: false }
+  ];
+  return new import_web38.TransactionInstruction({ keys, programId, data });
+}
+function createUpdateStvInstruction(params, accounts, programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([
+    UPDATE_STV_DISCRIMINATOR,
+    params.mgmtFeeBps !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU16(params.mgmtFeeBps)]) : Buffer.from([0]),
+    params.perfFeeBps !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU16(params.perfFeeBps)]) : Buffer.from([0]),
+    params.flags !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU16(params.flags)]) : Buffer.from([0]),
+    params.maxDeposit !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU64(params.maxDeposit)]) : Buffer.from([0]),
+    params.minDeposit !== void 0 ? Buffer.concat([Buffer.from([1]), serializeU64(params.minDeposit)]) : Buffer.from([0])
+  ]);
+  const keys = [
+    { pubkey: accounts.admin, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true }
+  ];
+  return new import_web38.TransactionInstruction({ keys, programId, data });
+}
+
+// src/instructions/user.ts
+var import_web39 = require("@solana/web3.js");
+var DEPOSIT_DISCRIMINATOR = Buffer.from([
+  248,
+  198,
+  158,
+  145,
+  225,
+  117,
+  135,
+  200
+]);
+var WITHDRAW_DISCRIMINATOR = Buffer.from([
+  183,
+  18,
+  70,
+  156,
+  148,
+  109,
+  161,
+  34
+]);
+function serializeU642(value) {
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(BigInt(value.toString()), 0);
+  return buf;
+}
+function createDepositInstruction(amount, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([DEPOSIT_DISCRIMINATOR, serializeU642(amount)]);
+  const keys = [
+    { pubkey: accounts.user, isSigner: true, isWritable: true },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jvMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.userBaseAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.userJvxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvBaseAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web39.TransactionInstruction({ keys, programId, data });
+}
+function createWithdrawInstruction(sharesToBurn, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([WITHDRAW_DISCRIMINATOR, serializeU642(sharesToBurn)]);
+  const keys = [
+    { pubkey: accounts.user, isSigner: true, isWritable: true },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jvMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.userBaseAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.userJvxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvBaseAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web39.TransactionInstruction({ keys, programId, data });
+}
+
+// src/instructions/manager.ts
+var import_web310 = require("@solana/web3.js");
+var JUP_EARN_DISCRIMINATOR = Buffer.from([
+  161,
+  178,
+  195,
+  212,
+  229,
+  246,
+  7,
+  24
+]);
+var MOVE_STV_DISCRIMINATOR = Buffer.from([
+  41,
+  58,
+  75,
+  92,
+  109,
+  126,
+  143,
+  144
+]);
+var SWAP_JLX_JLX_DISCRIMINATOR = Buffer.from([
+  65,
+  82,
+  99,
+  116,
+  133,
+  150,
+  167,
+  184
+]);
+var SWAP_JLX_JLP_DISCRIMINATOR = Buffer.from([
+  201,
+  218,
+  235,
+  252,
+  13,
+  30,
+  47,
+  48
+]);
+var SETTLE_YIELD_DISCRIMINATOR = Buffer.from([
+  81,
+  98,
+  115,
+  132,
+  149,
+  166,
+  183,
+  200
+]);
+function serializeU8(value) {
+  const buf = Buffer.alloc(1);
+  buf.writeUInt8(value, 0);
+  return buf;
+}
+function serializeU643(value) {
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(BigInt(value.toString()), 0);
+  return buf;
+}
+function createJupEarnInstruction(params, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const directionByte = params.direction === "Deposit" ? 0 : 1;
+  const data = Buffer.concat([
+    JUP_EARN_DISCRIMINATOR,
+    serializeU8(directionByte),
+    serializeU643(params.amount)
+  ]);
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: false },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvBaseAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web310.TransactionInstruction({ keys, programId, data });
+}
+function createMoveJlxInstruction(params, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const directionByte = params.direction === "ToVault" ? 0 : 1;
+  const data = Buffer.concat([
+    MOVE_STV_DISCRIMINATOR,
+    serializeU643(params.amountJlx),
+    serializeU8(directionByte)
+  ]);
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.vaultStagingAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web310.TransactionInstruction({ keys, programId, data });
+}
+function createSwapJlxJlxInstruction(params, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32LE(params.jupiterData.length, 0);
+  const data = Buffer.concat([
+    SWAP_JLX_JLX_DISCRIMINATOR,
+    serializeU8(params.fromIndex),
+    serializeU8(params.toIndex),
+    serializeU643(params.amountIn),
+    serializeU643(params.minOut),
+    lenBuf,
+    params.jupiterData
+  ]);
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.fromJlxMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.toJlxMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.fromJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.toJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.jupiterProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web310.TransactionInstruction({ keys, programId, data });
+}
+function createSwapJlxJlpInstruction(params, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const directionByte = params.direction === "JlxToJlp" ? 0 : 1;
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32LE(params.jupiterData.length, 0);
+  const data = Buffer.concat([
+    SWAP_JLX_JLP_DISCRIMINATOR,
+    serializeU8(params.stvIndex),
+    serializeU8(directionByte),
+    serializeU643(params.amountIn),
+    serializeU643(params.expectedAmountOut),
+    lenBuf,
+    params.jupiterData
+  ]);
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.vaultJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.vaultJlpAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.jlpMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.jupiterProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web310.TransactionInstruction({ keys, programId, data });
+}
+function createSettleYieldInstruction(params, accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const data = Buffer.concat([
+    SETTLE_YIELD_DISCRIMINATOR,
+    serializeU643(params.jlpRate)
+  ]);
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.vaultJlpAta, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlpMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.stvBtc, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvEth, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvSol, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvUsdc, isSigner: false, isWritable: true },
+    { pubkey: accounts.stvJupusd, isSigner: false, isWritable: true },
+    { pubkey: accounts.stagingBtc, isSigner: false, isWritable: false },
+    { pubkey: accounts.stagingEth, isSigner: false, isWritable: false },
+    { pubkey: accounts.stagingSol, isSigner: false, isWritable: false },
+    { pubkey: accounts.stagingUsdc, isSigner: false, isWritable: false },
+    { pubkey: accounts.stagingJupusd, isSigner: false, isWritable: false },
+    { pubkey: accounts.oracleBtc, isSigner: false, isWritable: false },
+    { pubkey: accounts.oracleEth, isSigner: false, isWritable: false },
+    { pubkey: accounts.oracleSol, isSigner: false, isWritable: false },
+    { pubkey: accounts.oracleJlp, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web310.TransactionInstruction({ keys, programId, data });
+}
+
+// src/instructions/fees.ts
+var import_web311 = require("@solana/web3.js");
+var CLAIM_FEES_DISCRIMINATOR = Buffer.from([
+  209,
+  226,
+  243,
+  4,
+  21,
+  38,
+  55,
+  72
+]);
+function createClaimFeesInstruction(accounts, remainingAccounts = [], programId = JLPD_PROGRAM_ID) {
+  const data = CLAIM_FEES_DISCRIMINATOR;
+  const keys = [
+    { pubkey: accounts.manager, isSigner: true, isWritable: false },
+    { pubkey: accounts.jlpVault, isSigner: false, isWritable: false },
+    { pubkey: accounts.stv, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jlMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.jvMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.stvBaseAta, isSigner: false, isWritable: false },
+    { pubkey: accounts.stvJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.feeReceiverJlxAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    ...remainingAccounts
+  ];
+  return new import_web311.TransactionInstruction({ keys, programId, data });
+}
+
+// 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) {
+    // 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;
+  }
+  static mainnet(connection) {
+    return new _JlpdClient(connection, JLPD_PROGRAM_ID);
+  }
+  static devnet(connection) {
+    const devnetProgramId = new import_web312.PublicKey(
+      "AcVcAihjB9Z3Lg3ZiboWxni2sTzXUrrsF3unGX4ntn6p"
+    );
+    return new _JlpdClient(connection, devnetProgramId);
+  }
+  // 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
+    };
+  }
+  // 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_web312.TransactionMessage({
+      payerKey: payer,
+      recentBlockhash: blockhash,
+      instructions: ixs
+    }).compileToV0Message(alts);
+    return new import_web312.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;
+    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 = createDepositInstruction(
+      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 }
+      ] : [],
+      this.client.programId
+    );
+    const message = new import_web312.TransactionMessage({
+      payerKey: params.user,
+      recentBlockhash: blockhash,
+      instructions: [ix]
+    }).compileToV0Message();
+    return new import_web312.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 = createWithdrawInstruction(
+      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 }
+      ] : [],
+      this.client.programId
+    );
+    const message = new import_web312.TransactionMessage({
+      payerKey: params.user,
+      recentBlockhash: blockhash,
+      instructions: [ix]
+    }).compileToV0Message();
+    return new import_web312.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 = createJupEarnInstruction(
+      { 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,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
+      },
+      remainingAccounts,
+      this.client.programId
+    );
+    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 = createMoveJlxInstruction(
+      { 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 }
+      ] : [],
+      this.client.programId
+    );
+    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 = createClaimFeesInstruction(
+      {
+        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 }
+      ] : [],
+      this.client.programId
+    );
+    return this.client.buildTransaction(params.manager, [ix]);
+  }
+  // Update STV parameters (admin only)
+  async updateStv(params) {
+    const ix = createUpdateStvInstruction(
+      {
+        mgmtFeeBps: params.mgmtFeeBps,
+        perfFeeBps: params.perfFeeBps,
+        flags: params.flags,
+        maxDeposit: params.maxDeposit,
+        minDeposit: params.minDeposit
+      },
+      {
+        admin: params.admin,
+        jlpVault: this.client.vaultPda,
+        stv: this.stvPda
+      },
+      this.client.programId
+    );
+    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 inputMint = params.direction === "JlxToJlp" ? poolConfig.fTokenMint : MINTS.JLP;
+    const outputMint = params.direction === "JlxToJlp" ? MINTS.JLP : poolConfig.fTokenMint;
+    const quote = await getJupiterQuote(
+      inputMint,
+      outputMint,
+      BigInt(params.amountIn.toString()),
+      params.slippageBps ?? 30
+    );
+    const swapIxs = await getJupiterSwapInstructions(quote, this.client.vaultPda);
+    const remainingAccounts = parseSwapRemainingAccounts(swapIxs.swapInstruction);
+    const alts = await fetchAddressLookupTables(
+      this.client.connection,
+      swapIxs.addressLookupTableAddresses
+    );
+    return {
+      inputMint,
+      outputMint,
+      inAmount: new import_anchor5.BN(quote.inAmount),
+      outAmount: new import_anchor5.BN(quote.outAmount),
+      minOutAmount: new import_anchor5.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
+    };
+  }
+  // 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_web312.ComputeBudgetProgram.setComputeUnitLimit({
+      units: params.quote.computeUnitLimit
+    });
+    const jupiterProgram = params.quote.remainingAccounts[0]?.pubkey ?? import_web312.PublicKey.default;
+    const swapIx = createSwapJlxJlpInstruction(
+      {
+        stvIndex: poolConfig.stvIndex,
+        direction: params.direction,
+        amountIn: params.amountIn,
+        expectedAmountOut: params.expectedOut,
+        jupiterData: params.quote.jupiterData
+      },
+      {
+        manager: params.manager,
+        jlpVault: this.client.vaultPda,
+        vaultJlxAta: poolCtx.vaultStagingAta,
+        vaultJlpAta: poolCtx.vaultJlpAta,
+        jlpMint: MINTS.JLP,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
+        jupiterProgram
+      },
+      params.quote.remainingAccounts,
+      this.client.programId
+    );
+    const { blockhash } = await this.client.connection.getLatestBlockhash("confirmed");
+    const message = new import_web312.TransactionMessage({
+      payerKey: params.manager,
+      recentBlockhash: blockhash,
+      instructions: [computeIx, swapIx]
+    }).compileToV0Message(params.quote.addressLookupTables);
+    return new import_web312.VersionedTransaction(message);
+  }
+  // Get a quote for jlX <-> jlX swap
+  async quoteJlxJlx(params) {
+    const fromPoolConfig = getPoolByName(params.fromPool);
+    const toPoolConfig = getPoolByName(params.toPool);
+    if (!fromPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.fromPool}`);
+    if (!toPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.toPool}`);
+    const inputMint = fromPoolConfig.fTokenMint;
+    const outputMint = toPoolConfig.fTokenMint;
+    const quote = await getJupiterQuote(
+      inputMint,
+      outputMint,
+      BigInt(params.amountIn.toString()),
+      params.slippageBps ?? 30
+    );
+    const swapIxs = await getJupiterSwapInstructions(quote, this.client.vaultPda);
+    const remainingAccounts = parseSwapRemainingAccounts(swapIxs.swapInstruction);
+    const alts = await fetchAddressLookupTables(
+      this.client.connection,
+      swapIxs.addressLookupTableAddresses
+    );
+    return {
+      inputMint,
+      outputMint,
+      inAmount: new import_anchor5.BN(quote.inAmount),
+      outAmount: new import_anchor5.BN(quote.outAmount),
+      minOutAmount: new import_anchor5.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
+    };
+  }
+  // Build jlX <-> jlX swap transaction
+  async swapJlxJlx(params) {
+    const fromPoolConfig = getPoolByName(params.fromPool);
+    const toPoolConfig = getPoolByName(params.toPool);
+    if (!fromPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.fromPool}`);
+    if (!toPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.toPool}`);
+    const fromPoolCtx = this.client.pool(params.fromPool);
+    const toPoolCtx = this.client.pool(params.toPool);
+    const computeIx = import_web312.ComputeBudgetProgram.setComputeUnitLimit({
+      units: params.quote.computeUnitLimit
+    });
+    const jupiterProgram = params.quote.remainingAccounts[0]?.pubkey ?? import_web312.PublicKey.default;
+    const swapIx = createSwapJlxJlxInstruction(
+      {
+        fromIndex: fromPoolConfig.stvIndex,
+        toIndex: toPoolConfig.stvIndex,
+        amountIn: params.amountIn,
+        minOut: params.minOut,
+        jupiterData: params.quote.jupiterData
+      },
+      {
+        manager: params.manager,
+        jlpVault: this.client.vaultPda,
+        fromJlxMint: fromPoolConfig.fTokenMint,
+        toJlxMint: toPoolConfig.fTokenMint,
+        fromJlxAta: fromPoolCtx.vaultStagingAta,
+        toJlxAta: toPoolCtx.vaultStagingAta,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
+        jupiterProgram
+      },
+      params.quote.remainingAccounts,
+      this.client.programId
+    );
+    const { blockhash } = await this.client.connection.getLatestBlockhash("confirmed");
+    const message = new import_web312.TransactionMessage({
+      payerKey: params.manager,
+      recentBlockhash: blockhash,
+      instructions: [computeIx, swapIx]
+    }).compileToV0Message(params.quote.addressLookupTables);
+    return new import_web312.VersionedTransaction(message);
+  }
+};
+var AdminContext = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // Initialize or update vault
+  async initOrUpdateVault(params) {
+    const ix = createInitOrUpdateVaultInstruction(
+      {
+        jlpMint: params.jlpMint ?? null,
+        baseAssetMints: params.baseAssetMints ?? null,
+        jlxAssetMints: params.jlxAssetMints ?? null,
+        newAdmin: params.newAdmin ?? null,
+        manager: params.manager,
+        feeReceiver: params.feeReceiver,
+        flags: params.flags,
+        jlpSlippageBps: params.jlpSlippageBps,
+        oracleStalenessThreshold: params.oracleStalenessThreshold ?? null
+      },
+      {
+        admin: params.admin,
+        jlpVault: this.client.vaultPda,
+        systemProgram: import_web312.SystemProgram.programId
+      },
+      this.client.programId
+    );
+    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 [stvPda] = deriveStvPda(pool.mint, this.client.programId);
+    const stvJlxAta = (0, import_spl_token5.getAssociatedTokenAddressSync)(pool.fTokenMint, stvPda, true);
+    const ix = createInitializeStvInstruction(
+      {
+        mgmtFeeBps: params.mgmtFeeBps,
+        perfFeeBps: params.perfFeeBps,
+        maxDeposit: params.maxDeposit,
+        minDeposit: params.minDeposit
+      },
+      {
+        admin: params.admin,
+        jlpVault: this.client.vaultPda,
+        stv: stvPda,
+        baseMint: pool.mint,
+        jlMint: pool.fTokenMint,
+        jvMint: jvMintKeypair,
+        stvJlxAta,
+        systemProgram: import_web312.SystemProgram.programId,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
+        associatedTokenProgram: import_spl_token5.ASSOCIATED_TOKEN_PROGRAM_ID,
+        rent: import_web312.SYSVAR_RENT_PUBKEY
+      },
+      this.client.programId
+    );
+    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_web312.PublicKey.default,
+      isSigner: false,
+      isWritable: false
+    }));
+    const rewardsAccounts = pools.map((p) => ({
+      pubkey: p.hasJupiterLend ? p.rewardsRateModel : import_web312.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 = createSettleYieldInstruction(
+      { jlpRate: params.jlpRate },
+      {
+        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,
+        oracleJlp: ORACLES.PYTH_JLP_USD
+      },
+      remainingAccounts,
+      this.client.programId
+    );
+    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_VAULT_ACCOUNT_SIZE,
+  JLP_VAULT_DATA_SIZE,
+  JLP_VAULT_DISCRIMINATOR,
+  JUPITER_LEND_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,
+  createSettleYieldInstruction,
+  createSwapJlxJlpInstruction,
+  createSwapJlxJlxInstruction,
+  createUpdateStvInstruction,
+  createWithdrawInstruction,
+  deriveAta,
+  deriveStvAtas,
+  deriveStvPda,
+  deriveUserAtas,
+  deriveVaultAtas,
+  deriveVaultPda,
+  fetchAddressLookupTables,
+  fetchJlpRate,
+  fetchJupiterPriceUsd,
+  getJupiterQuote,
+  getJupiterSwapInstructions,
+  getPoolByMint,
+  getPoolByName,
+  jlxToBase,
+  parseLendingAccount,
+  parseRewardsRateModel,
+  parseStv,
+  parseSwapRemainingAccounts,
+  parseVault,
+  sharesToBase
+});