@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/chunk-2T23QQCX.mjs

@@ -0,0 +1,3707 @@
+// ../../shared/common/src/constants/general.ts
+import { address } from "@solana/kit";
+var ENVIRONMENT = process.env.ENVIRONMENT ?? "local";
+var DAYS_PER_YEAR = 365;
+var TVL_USD_DECIMAL_PLACES = 8;
+var TVL_USD_SCALE = BigInt(10 ** TVL_USD_DECIMAL_PLACES);
+var BPS_DENOMINATOR = 10000n;
+var DEFAULT_PUBLIC_KEY = address("11111111111111111111111111111111");
+var LOCALNET_URL = "http://127.0.0.1:8899";
+var PROTOCOL_ADMIN = {
+  local: address("7PxS1VMxKbzUTF4sxeAw4LqBfnGMaeQH2KwabmUcVxYC"),
+  test: address("8S1Ta7xZVsiqtf9mrUPwXKSNmBPzmsK3RdhonDu3kzk"),
+  prod: address("42GmTZiLdcJHmxCik4WvxTYeNirzFqsr7DXWZDst4gxE")
+  // TODO: multisig admin
+};
+var DEPLOYED_ADMIN_KEYPAIR_FP = {
+  test: "~/.config/solana/tp/lyc-admin-test.json",
+  prod: "~/.config/solana/tp/lyc-admin-prod.json"
+};
+var PRICE_STALENESS_SECONDS = 60;
+var METAPLEX_TOKEN_METADATA_PROGRAM_ID = address(
+  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+);
+
+// ../../shared/common/src/utils/transaction.ts
+import {
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageLifetimeUsingBlockhash,
+  appendTransactionMessageInstructions,
+  compressTransactionMessageUsingAddressLookupTables,
+  compileTransaction as compileTransaction3,
+  signTransactionMessageWithSigners,
+  getSignatureFromTransaction,
+  getBase64EncodedWireTransaction as getBase64EncodedWireTransaction2,
+  setTransactionMessageFeePayerSigner,
+  addSignersToTransactionMessage,
+  assertIsFullySignedTransaction,
+  isTransactionModifyingSigner,
+  isTransactionPartialSigner
+} from "@solana/kit";
+
+// ../../shared/common/src/utils/instruction.ts
+import {
+  getRequestHeapFrameInstruction,
+  getSetComputeUnitLimitInstruction,
+  getSetComputeUnitPriceInstruction
+} from "@solana-program/compute-budget";
+import {
+  fetchMaybeToken as fetchMaybeToken2,
+  getCreateAssociatedTokenIdempotentInstruction,
+  getSyncNativeInstruction,
+  getCloseAccountInstruction,
+  TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS3
+} from "@solana-program/token";
+import { getTransferSolInstruction } from "@solana-program/system";
+
+// ../../shared/common/src/services/baseAccountClient.ts
+import { fetchMaybeToken } from "@solana-program/token";
+
+// ../../shared/common/src/services/dataCache.ts
+var DataCache = class {
+  constructor(ttlConfig) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttlConfig = {
+      defaultTtlMs: ttlConfig?.defaultTtlMs ?? 6e4 * 5,
+      // 5 minute default
+      categoryTtlMs: ttlConfig?.categoryTtlMs ?? {}
+    };
+  }
+  async getData(fetchFn, category, id, options) {
+    let data = this.tryFromCache(category, id);
+    let fromCache = true;
+    if (!data) {
+      data = await fetchFn();
+      if (data !== null || options?.cacheNull !== false) {
+        this.setCache(category, id, data);
+      }
+      fromCache = false;
+    }
+    return { data, fromCache };
+  }
+  async getDataOrThrow(fetchFn, category, id, options) {
+    const { data, fromCache } = await this.getData(fetchFn, category, id, options);
+    if (!data) {
+      throw new Error(`Failed to fetch ${category} data, ID: ${id}`);
+    }
+    return { data, fromCache };
+  }
+  async getDataBatch(fetchFn, category, ids) {
+    let data = ids.map((id) => this.tryFromCache(category, id));
+    let fromCache = true;
+    if (data.some((item) => item === null)) {
+      data = await fetchFn();
+      if (!data) {
+        throw new Error(`Failed to batch fetch ${category} data`);
+      }
+      for (let i = 0; i < ids.length; i++) {
+        this.setCache(category, ids[i], data[i]);
+      }
+      fromCache = false;
+    }
+    return { data, fromCache };
+  }
+  getTtlForCategory(category) {
+    return this.ttlConfig.categoryTtlMs?.[category] ?? this.ttlConfig.defaultTtlMs;
+  }
+  isStale(entry, category) {
+    const ttl = this.getTtlForCategory(category);
+    const age = Date.now() - entry.timestamp;
+    return age > ttl;
+  }
+  /** Returns null if not found or stale */
+  tryFromCache(category, id) {
+    const categoryCache = this.cache.get(category);
+    if (!categoryCache) {
+      return null;
+    }
+    const entry = categoryCache.get(id);
+    if (!entry) {
+      return null;
+    }
+    if (this.isStale(entry, category)) {
+      categoryCache.delete(id);
+      return null;
+    }
+    return entry.data;
+  }
+  getCacheAge(category, id) {
+    const categoryCache = this.cache.get(category);
+    if (!categoryCache) {
+      return null;
+    }
+    const entry = categoryCache.get(id);
+    if (!entry) {
+      return null;
+    }
+    return Date.now() - entry.timestamp;
+  }
+  setCache(category, id, data) {
+    let categoryCache = this.cache.get(category);
+    if (!categoryCache) {
+      categoryCache = /* @__PURE__ */ new Map();
+      this.cache.set(category, categoryCache);
+    }
+    categoryCache.set(id, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  refreshCategory(category) {
+    const categoryCache = this.cache.get(category);
+    if (categoryCache) {
+      categoryCache.clear();
+    }
+  }
+  clearCacheEntry(category, id) {
+    const categoryCache = this.cache.get(category);
+    if (!categoryCache) {
+      return false;
+    }
+    return categoryCache.delete(id);
+  }
+  clearStaleEntries(category) {
+    const categoryCache = this.cache.get(category);
+    if (!categoryCache) {
+      return 0;
+    }
+    let cleared = 0;
+    for (const [id, entry] of categoryCache.entries()) {
+      if (this.isStale(entry, category)) {
+        categoryCache.delete(id);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+  clearAllStaleEntries() {
+    let totalCleared = 0;
+    for (const category of this.cache.keys()) {
+      totalCleared += this.clearStaleEntries(category);
+    }
+    return totalCleared;
+  }
+  clearAllCache() {
+    this.cache.clear();
+  }
+};
+
+// ../../shared/common/src/services/baseAccountClient.ts
+var SPL_ATA_CACHE_CATEGORY = "splAta";
+var DEFAULT_SPL_ATA_TTL_MS = 6e4 * 10;
+var BaseAccountClient = class {
+  constructor(rpc, options) {
+    this.rpc = rpc;
+    this.dataCache = new DataCache({
+      defaultTtlMs: options?.defaultTtlMs,
+      categoryTtlMs: {
+        [SPL_ATA_CACHE_CATEGORY]: DEFAULT_SPL_ATA_TTL_MS,
+        ...options?.categoryTtlMs
+      }
+    });
+  }
+  /**
+   * Whether an SPL token account exists at `ata`. Cached under {@link SPL_ATA_CACHE_CATEGORY};
+   * clear via post-success `splAta` transaction cache invalidations after successful creates.
+   */
+  async splAtaExists(ata) {
+    const { data } = await this.dataCache.getData(
+      async () => (await fetchMaybeToken(this.rpc, ata)).exists,
+      SPL_ATA_CACHE_CATEGORY,
+      ata
+    );
+    return data ?? false;
+  }
+};
+
+// ../../shared/common/src/utils/solana.ts
+import {
+  createKeyPairSignerFromBytes
+} from "@solana/kit";
+import { Keypair } from "@solana/web3.js";
+
+// ../../shared/common/src/utils/general.ts
+function deduplicateAccounts(addresses) {
+  return Array.from(new Set(addresses).values());
+}
+function dedupeOrdered(items, key) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const k = key(item);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    ordered.push(item);
+  }
+  return ordered;
+}
+function dedupeOrderedAddresses(addresses) {
+  return dedupeOrdered(addresses, (a) => a);
+}
+function filterSpecificAccounts(addresses, excluded) {
+  const excludedSet = new Set(excluded);
+  return addresses.filter((address9) => !excludedSet.has(address9));
+}
+function zip(list1, list2) {
+  const minLength = Math.min(list1.length, list2.length);
+  const result = [];
+  for (let i = 0; i < minLength; i++) {
+    result.push([list1[i], list2[i]]);
+  }
+  return result;
+}
+function maxByNumber(items, score) {
+  if (items.length === 0) {
+    throw new Error("maxByNumber: empty items");
+  }
+  let best = items[0];
+  let bestScore = score(best);
+  for (let i = 1; i < items.length; i++) {
+    const item = items[i];
+    const s = score(item);
+    if (s > bestScore) {
+      best = item;
+      bestScore = s;
+    }
+  }
+  return best;
+}
+function createRecord(keys, values) {
+  return Object.fromEntries(zip(keys, values).map(([k, v]) => [k.toString(), v]));
+}
+function findKeyIgnoreCase(record, key) {
+  const lower = key.toLowerCase();
+  return Object.keys(record).find((k) => k.toLowerCase() === lower);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ../../shared/common/src/utils/solana.ts
+function createSignerFromAddress(address9) {
+  return { address: address9 };
+}
+async function getSlot(rpc, commitment = "confirmed") {
+  return rpc.getSlot({ commitment }).send();
+}
+function isTransactionSigner(x) {
+  return typeof x === "object" && x !== null && "address" in x && typeof x.address === "string";
+}
+
+// ../../shared/common/src/utils/accounts/pda.ts
+import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+
+// ../../shared/common/src/utils/compat.ts
+import { PublicKey } from "@solana/web3.js";
+import { AccountRole, address as address2 } from "@solana/kit";
+function toWeb3Pk(addr) {
+  return new PublicKey(addr);
+}
+function fromWeb3Pk(addr) {
+  return address2(addr.toString());
+}
+function toWeb3AccountMeta(account) {
+  return {
+    pubkey: new PublicKey(account.address),
+    isSigner: account.role === AccountRole.READONLY_SIGNER || account.role === AccountRole.WRITABLE_SIGNER,
+    isWritable: account.role === AccountRole.WRITABLE || account.role === AccountRole.WRITABLE_SIGNER
+  };
+}
+function toKitInstruction(ix) {
+  return {
+    programAddress: ix.programId.toBase58(),
+    data: new Uint8Array(ix.data),
+    accounts: ix.keys.map((key) => ({
+      address: key.pubkey.toBase58(),
+      role: key.isWritable ? key.isSigner ? AccountRole.WRITABLE_SIGNER : AccountRole.WRITABLE : key.isSigner ? AccountRole.READONLY_SIGNER : AccountRole.READONLY
+    }))
+  };
+}
+
+// ../../shared/common/src/utils/accounts/pda.ts
+function deriveAssociatedTokenAddress(mint, owner, tokenProgram) {
+  const [ata] = PublicKey2.findProgramAddressSync(
+    [toWeb3Pk(owner).toBuffer(), toWeb3Pk(tokenProgram).toBuffer(), toWeb3Pk(mint).toBuffer()],
+    new PublicKey2(ASSOCIATED_TOKEN_PROGRAM_ADDRESS)
+  );
+  return fromWeb3Pk(ata);
+}
+async function getAtaAddress(mint, owner, tokenProgram = TOKEN_PROGRAM_ADDRESS) {
+  return deriveAssociatedTokenAddress(mint, owner, tokenProgram);
+}
+
+// ../../shared/common/src/utils/accounts/rpc.ts
+async function allAccountsExist(rpc, addresses) {
+  if (!addresses.length) {
+    return {
+      existingAddresses: [],
+      missingAddresses: [],
+      existsByAddress: /* @__PURE__ */ new Map()
+    };
+  }
+  const uniqueAddresses = [...new Set(addresses)];
+  const response = await rpc.getMultipleAccounts(uniqueAddresses, { encoding: "base64" }).send();
+  const existsByAddress = /* @__PURE__ */ new Map();
+  for (let i = 0; i < uniqueAddresses.length; i += 1) {
+    existsByAddress.set(uniqueAddresses[i], response.value[i] !== null);
+  }
+  return {
+    existingAddresses: uniqueAddresses.filter((address9) => existsByAddress.get(address9)),
+    missingAddresses: uniqueAddresses.filter((address9) => !existsByAddress.get(address9)),
+    existsByAddress
+  };
+}
+async function accountExists(rpc, address9) {
+  const accountInfo = await rpc.getAccountInfo(address9, { encoding: "base64" }).send();
+  return accountInfo.value !== null;
+}
+
+// ../../shared/common/src/services/mints/registry.ts
+import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
+import { TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
+
+// ../../shared/common/src/services/mints/defaults.ts
+import { address as address3 } from "@solana/kit";
+var DEFAULT_MINTS = [
+  // Risk assets
+  {
+    address: address3("So11111111111111111111111111111111111111112"),
+    symbol: "SOL",
+    name: "Solana",
+    decimals: 9,
+    assetType: "Standard"
+  },
+  {
+    address: address3("3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"),
+    symbol: "wBTC",
+    name: "Wrapped Bitcoin",
+    decimals: 8,
+    assetType: "Standard"
+  },
+  {
+    address: address3("cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij"),
+    symbol: "cbBTC",
+    name: "Coinbase Wrapped Bitcoin",
+    decimals: 8,
+    assetType: "Standard"
+  },
+  {
+    address: address3("7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"),
+    symbol: "wETH",
+    name: "Wrapped Ethereum",
+    decimals: 8,
+    assetType: "Standard"
+  },
+  {
+    address: address3("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4"),
+    symbol: "JLP",
+    name: "Jupiter Perps LP",
+    decimals: 6,
+    assetType: "Standard"
+  },
+  {
+    address: address3("XsoCS1TfEyfFhfvj8EtZ528L3CaKBDBRqRapnBbDF2W"),
+    symbol: "SPYx",
+    name: "SP500 xStock",
+    decimals: 8,
+    assetType: "Standard",
+    isToken2022: true
+  },
+  {
+    address: address3("Xs8S1uUs1zvS2p7iwtsG3b6fkhpvmwz4GYU3gWAmWHZ"),
+    symbol: "QQQx",
+    name: "Nasdaq xStock",
+    decimals: 8,
+    assetType: "Standard",
+    isToken2022: true
+  },
+  // Stablecoins
+  {
+    address: address3("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+    symbol: "USDC",
+    name: "USD Coin",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: address3("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"),
+    symbol: "USDT",
+    name: "Tether USD",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: address3("USDSwr9ApdHk5bvJKMjzff41FfuX8bSxdKcR81vTwcA"),
+    symbol: "USDS",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: address3("2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH"),
+    symbol: "USDG",
+    name: "Global Dollar",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: address3("2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo"),
+    symbol: "PYUSD",
+    name: "PayPal USD",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: address3("CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH"),
+    symbol: "CASH",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: address3("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB"),
+    symbol: "USD1",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  // LSTs
+  {
+    address: address3("J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"),
+    symbol: "JitoSOL",
+    name: "Jito SOL",
+    decimals: 9,
+    assetType: "LST"
+  },
+  {
+    address: address3("jupSoLaHXQiZZTSfEWMTRRgpnyFm8f6sZdosWBjx93v"),
+    symbol: "JupSOL",
+    name: "Jupiter Staked SOL",
+    decimals: 9,
+    assetType: "LST"
+  },
+  {
+    address: address3("sctmB7GPi5L2Q5G9tUSzXvhZ4YiDMEGcRov9KfArQpx"),
+    symbol: "dfdvSOL",
+    name: "DeFi Development Corp SOL",
+    decimals: 9,
+    assetType: "LST"
+  },
+  // Yield bearing assets
+  {
+    address: address3("star9agSpjiFe3M49B3RniVU4CMBBEK3Qnaqn3RGiFM"),
+    symbol: "USD*",
+    name: "USD Star",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: address3("3AJYCjrhKitmBd8tRUurPA5dGHCAQh6A8L9DkuSC37Rm"),
+    symbol: "USD*-J",
+    name: "USD Star Junior",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: address3("59obFNBzyTBGowrkif5uK7ojS58vsuWz3ZCvg6tfZAGw"),
+    symbol: "PST",
+    name: "PayFi Strategy Token",
+    decimals: 6,
+    assetType: "YBA"
+  }
+];
+
+// ../../shared/common/src/utils/numbers.ts
+import { BN } from "@anchor-lang/core";
+var U64_MAX = BigInt("18446744073709551615");
+var U64_MAX_BN = new BN(U64_MAX.toString());
+function toUiAmount(amount, decimals) {
+  const bigintValue = typeof amount === "bigint" ? amount : BigInt(amount.toString());
+  if (bigintValue >= U64_MAX) {
+    return Infinity;
+  }
+  if (bigintValue <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(bigintValue) / Math.pow(10, decimals);
+  }
+  const divisor = BigInt(Math.pow(10, decimals));
+  const wholePart = bigintValue / divisor;
+  const remainder = bigintValue % divisor;
+  return Number(wholePart) + Number(remainder) / Math.pow(10, decimals);
+}
+function fromUiAmount(amount, decimals) {
+  return new BN(Math.round(amount * Math.pow(10, decimals)));
+}
+function wholeTokenAmount(decimals) {
+  return Math.pow(10, decimals);
+}
+function calculateTvlUsd(amount, price, decimals) {
+  const assetScale = BigInt(wholeTokenAmount(decimals));
+  const scaleFactor = assetScale * assetScale / TVL_USD_SCALE;
+  return amount * price / scaleFactor;
+}
+function tvlUsdToBaseUnits(tvlUsd, price, decimals) {
+  const assetScale = BigInt(wholeTokenAmount(decimals));
+  const scaleFactor = assetScale * assetScale / TVL_USD_SCALE;
+  return tvlUsd * scaleFactor / price;
+}
+function bnFromBigInt(n) {
+  return new BN(n.toString());
+}
+function applyFeeCeil(principal, feeRate) {
+  if (feeRate <= 0) return 0n;
+  const scale = 1000000000n;
+  const rateScaled = BigInt(Math.ceil(feeRate * Number(scale)));
+  const numerator = principal * rateScaled;
+  return (numerator + (scale - 1n)) / scale;
+}
+function getBatches(items, batchSize) {
+  const batches = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+function currentUnixSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function sum(numbers) {
+  return numbers.reduce((prev, curr) => prev + curr, 0);
+}
+function toBigInt(value) {
+  return BigInt(value.toString());
+}
+function applyBps(value, bps) {
+  return value * BigInt(bps) / BPS_DENOMINATOR;
+}
+function toSafeNumber(value, field) {
+  const asBigInt = typeof value === "bigint" ? value : BigInt(value.toString());
+  if (asBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`${field} exceeds Number.MAX_SAFE_INTEGER and cannot be quoted safely`);
+  }
+  return Number(asBigInt);
+}
+function numberToLEBytes(value, byteLength = 8) {
+  const bigintValue = typeof value === "bigint" ? value : BigInt(value.toString());
+  const buf = new ArrayBuffer(byteLength);
+  const view = new DataView(buf);
+  if (byteLength === 8) {
+    view.setBigUint64(0, bigintValue, true);
+  } else {
+    let remaining = bigintValue;
+    for (let i = 0; i < byteLength; i++) {
+      view.setUint8(i, Number(remaining & 0xffn));
+      remaining >>= 8n;
+    }
+  }
+  return new Uint8Array(buf);
+}
+function numToU64Bytes(value) {
+  return numberToLEBytes(value, 8);
+}
+
+// ../../shared/common/src/services/mints/registry.ts
+var MintRegistry = class {
+  constructor(options = {}) {
+    this.byAddress = /* @__PURE__ */ new Map();
+    this.bySymbol = /* @__PURE__ */ new Map();
+    const { includeDefaults = true, custom = [] } = options;
+    if (includeDefaults) {
+      for (const config of DEFAULT_MINTS) {
+        this.register(config);
+      }
+    }
+    for (const config of custom) {
+      this.register(config);
+    }
+  }
+  /**
+   * Register a new mint configuration.
+   * Overwrites existing entries with the same address or symbol.
+   */
+  register(config) {
+    const mintInfo = {
+      ...config,
+      tokenProgram: config.isToken2022 ? TOKEN_2022_PROGRAM_ADDRESS : TOKEN_PROGRAM_ADDRESS2,
+      toUiAmount: (amount) => toUiAmount(amount, config.decimals),
+      fromUiAmount: (amount) => fromUiAmount(amount, config.decimals)
+    };
+    this.byAddress.set(config.address, mintInfo);
+    this.bySymbol.set(config.symbol.toUpperCase(), mintInfo);
+  }
+  /**
+   * Get mint information by address or symbol.
+   *
+   * @param mint - Mint address or token symbol (case-insensitive)
+   * @returns MintInfo if found, undefined otherwise
+   *
+   * @example
+   * ```typescript
+   * mints.get("USDC")?.decimals  // 6
+   * mints.get(usdcAddress)?.symbol  // "USDC"
+   * ```
+   */
+  get(mint) {
+    const upperKey = mint.toUpperCase();
+    const bySymbol = this.bySymbol.get(upperKey);
+    if (bySymbol) {
+      return bySymbol;
+    }
+    return this.byAddress.get(mint);
+  }
+  all() {
+    return Array.from(this.byAddress.values());
+  }
+  standardAssets() {
+    return this.filterAssetsByType("Standard");
+  }
+  stablecoins() {
+    return this.filterAssetsByType("Stablecoin");
+  }
+  lsts() {
+    return this.filterAssetsByType("LST");
+  }
+  yieldBearingAssets() {
+    return this.filterAssetsByType("YBA");
+  }
+  filterAssetsByType(assetType) {
+    return Array.from(this.byAddress.values()).filter((x) => x.assetType === assetType);
+  }
+  symbols() {
+    return Array.from(this.bySymbol.keys());
+  }
+  addresses() {
+    return Array.from(this.byAddress.keys());
+  }
+};
+var mints = new MintRegistry();
+
+// ../../shared/common/src/services/mints/symbols.ts
+function mintSymbol(mint, registry = mints) {
+  return registry.get(mint)?.symbol ?? String(mint).slice(0, 6);
+}
+
+// ../../shared/common/src/utils/instruction.ts
+function setComputeUnitLimitIx(maxComputeUnits) {
+  return getSetComputeUnitLimitInstruction({
+    units: maxComputeUnits
+  });
+}
+function setComputeUnitPriceIx(microLamports) {
+  return getSetComputeUnitPriceInstruction({
+    microLamports
+  });
+}
+function requestHeapFrameIx(bytes) {
+  return getRequestHeapFrameInstruction({ bytes });
+}
+async function getCreateAtaInstructions(rpc, payer, accounts) {
+  const requiredAtas = accounts.filter((x) => x.isRequiredAta);
+  if (!requiredAtas.length) {
+    return { instructions: [], postSuccessCacheInvalidations: [] };
+  }
+  const { existsByAddress } = await allAccountsExist(
+    rpc,
+    requiredAtas.map((account) => account.address)
+  );
+  const payerSigner = createSignerFromAddress(payer);
+  const instructions = [];
+  const postSuccessCacheInvalidations = [];
+  for (const account of requiredAtas) {
+    if (!existsByAddress.get(account.address)) {
+      const seeds = account.isRequiredAta;
+      instructions.push(
+        getCreateAssociatedTokenIdempotentInstruction({
+          payer: payerSigner,
+          ata: account.address,
+          owner: seeds.owner,
+          mint: seeds.mint,
+          tokenProgram: seeds.tokenProgram
+        })
+      );
+      postSuccessCacheInvalidations.push({ client: SPL_ATA_CACHE_CATEGORY, ata: account.address });
+    }
+  }
+  return { instructions, postSuccessCacheInvalidations };
+}
+async function getCreateAtaIxIfNeeded(rpc, payer, mint, owner, tokenProgram = TOKEN_PROGRAM_ADDRESS3, options) {
+  const ata = await getAtaAddress(mint, owner, tokenProgram);
+  const exists = options?.accountClient !== void 0 ? await options.accountClient.splAtaExists(ata) : (await fetchMaybeToken2(rpc, ata)).exists;
+  if (exists) {
+    return { instruction: null, postSuccessCacheInvalidations: [] };
+  }
+  const payerSigner = isTransactionSigner(payer) ? payer : createSignerFromAddress(payer);
+  const instruction = getCreateAssociatedTokenIdempotentInstruction({
+    payer: payerSigner,
+    ata,
+    owner,
+    mint,
+    tokenProgram
+  });
+  return {
+    instruction,
+    postSuccessCacheInvalidations: [{ client: SPL_ATA_CACHE_CATEGORY, ata }]
+  };
+}
+async function getWrapSolInstructions(rpc, owner, payer, lamports, createAtaOptions) {
+  const solMint = mints.get("SOL");
+  const solMintAddress = solMint.address;
+  const ata = await getAtaAddress(solMintAddress, owner);
+  const { instruction: createAtaIx, postSuccessCacheInvalidations } = await getCreateAtaIxIfNeeded(
+    rpc,
+    payer,
+    solMintAddress,
+    owner,
+    TOKEN_PROGRAM_ADDRESS3,
+    createAtaOptions
+  );
+  const instructions = [];
+  if (createAtaIx) instructions.push(createAtaIx);
+  instructions.push(
+    getTransferSolInstruction({
+      source: payer,
+      destination: ata,
+      amount: BigInt(lamports.toString())
+    }),
+    getSyncNativeInstruction({ account: ata })
+  );
+  return { instructions, postSuccessCacheInvalidations };
+}
+async function getUnwrapSolInstruction(owner, destination) {
+  const solMint = mints.get("SOL");
+  if (!solMint) throw new Error("WSOL mint not found in registry");
+  const solMintAddress = solMint.address;
+  const ata = await getAtaAddress(solMintAddress, owner.address);
+  return getCloseAccountInstruction({
+    account: ata,
+    destination: destination ?? owner.address,
+    owner
+  });
+}
+
+// ../../shared/common/src/services/lutManager.ts
+import { getProgramDerivedAddress as getProgramDerivedAddress2, getAddressEncoder as getAddressEncoder2, getU64Encoder } from "@solana/kit";
+import {
+  getCreateLookupTableInstruction,
+  getExtendLookupTableInstruction,
+  fetchAddressLookupTable,
+  ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS
+} from "@solana-program/address-lookup-table";
+
+// ../../shared/common/src/utils/accounts/roles.ts
+import { AccountRole as AccountRole2, upgradeRoleToSigner, upgradeRoleToWritable } from "@solana/kit";
+function isRoleWritable(role) {
+  return role === AccountRole2.WRITABLE || role === AccountRole2.WRITABLE_SIGNER;
+}
+function isRoleSigner(role) {
+  return role === AccountRole2.READONLY_SIGNER || role === AccountRole2.WRITABLE_SIGNER;
+}
+function getAccountRole(isWritable, isSigner) {
+  let role = AccountRole2.READONLY;
+  if (isWritable) role = upgradeRoleToWritable(role);
+  if (isSigner) role = upgradeRoleToSigner(role);
+  return role;
+}
+function downgradeRoleFromSigner(role) {
+  if (role === AccountRole2.READONLY_SIGNER) return AccountRole2.READONLY;
+  if (role === AccountRole2.WRITABLE_SIGNER) return AccountRole2.WRITABLE;
+  return role;
+}
+function stripSignerFromAccounts(accounts) {
+  return accounts.map((acc) => ({
+    ...acc,
+    role: downgradeRoleFromSigner(acc.role)
+  }));
+}
+
+// ../../shared/common/src/utils/accounts/meta.ts
+function toCustomAccountMeta(address9, isWritable, requiredAtaDetails, isSigner) {
+  const role = getAccountRole(isWritable ?? false, isSigner ?? false);
+  return { address: address9, role, isRequiredAta: requiredAtaDetails };
+}
+function toCustomAccountMetaFromWeb3AccountMeta(web3AccountMeta) {
+  return toCustomAccountMeta(
+    web3AccountMeta.pubkey.toBase58(),
+    web3AccountMeta.isWritable,
+    void 0,
+    web3AccountMeta.isSigner
+  );
+}
+
+// ../../shared/common/src/utils/accounts/splBalances.ts
+var SPL_TOKEN_ACCOUNT_AMOUNT_OFFSET = 64;
+var GET_MULTIPLE_ACCOUNTS_MAX_KEYS = 100;
+async function fetchSplTokenAccountAmounts(rpc, tokenAccounts) {
+  if (tokenAccounts.length === 0) return /* @__PURE__ */ new Map();
+  const chunks = [];
+  for (let i = 0; i < tokenAccounts.length; i += GET_MULTIPLE_ACCOUNTS_MAX_KEYS) {
+    chunks.push(tokenAccounts.slice(i, i + GET_MULTIPLE_ACCOUNTS_MAX_KEYS));
+  }
+  const balances = /* @__PURE__ */ new Map();
+  await Promise.all(
+    chunks.map(async (chunk) => {
+      const response = await rpc.getMultipleAccounts(chunk, { encoding: "base64" }).send();
+      for (let i = 0; i < chunk.length; i++) {
+        const entry = response.value[i];
+        if (!entry) continue;
+        const buf = Buffer.from(entry.data[0], "base64");
+        balances.set(chunk[i], buf.readBigUInt64LE(SPL_TOKEN_ACCOUNT_AMOUNT_OFFSET));
+      }
+    })
+  );
+  return balances;
+}
+
+// ../../shared/common/src/utils/data.ts
+function applyDataCacheTransactionInvalidations(dataCache, invalidations, options) {
+  for (const inv of invalidations) {
+    if (inv.client === "lycToken") {
+      dataCache.clearCacheEntry(options.tokenPdaCategory, inv.tokenPda);
+    } else if (inv.client === "lycYieldingBank") {
+      dataCache.clearCacheEntry(options.yieldingBankPdaCategory, inv.yieldingBankPda);
+    } else if (inv.client === "splAta") {
+      dataCache.clearCacheEntry(SPL_ATA_CACHE_CATEGORY, inv.ata);
+    } else if (inv.client === "perena") {
+      inv.dataCache.clearCacheEntry(inv.category, inv.id);
+    }
+  }
+}
+
+// ../../shared/common/src/utils/cpi/args.ts
+var SKIP_SENTINEL = 65535;
+function serializeArgs(data) {
+  if (data === void 0) {
+    const buf2 = Buffer.alloc(2);
+    buf2.writeUInt16LE(SKIP_SENTINEL);
+    return buf2;
+  }
+  const len = data.length;
+  const buf = Buffer.alloc(2 + len);
+  buf.writeUInt16LE(len);
+  if (len > 0) {
+    Buffer.from(data).copy(buf, 2);
+  }
+  return buf;
+}
+var CpiArgsBuilder = class {
+  constructor() {
+    this.parts = [];
+  }
+  /**
+   * Add client-provided args for the next CPI slot.
+   * Automatically wraps with a u16 LE length prefix.
+   */
+  add(data) {
+    this.parts.push(serializeArgs(data));
+    return this;
+  }
+  /**
+   * Mark the next CPI slot as a no-args instruction (length = 0).
+   * The Rust side will invoke the CPI with empty instruction data.
+   */
+  noArgs() {
+    this.parts.push(serializeArgs(Buffer.alloc(0)));
+    return this;
+  }
+  /**
+   * Mark the next CPI slot as program-provided (sentinel 0xFFFF).
+   * The Rust handler must compute args and call `invoke_cpi` directly.
+   */
+  skip() {
+    this.parts.push(serializeArgs());
+    return this;
+  }
+  /** Build the final packed buffer. */
+  build() {
+    return Buffer.concat(this.parts);
+  }
+};
+
+// ../../shared/common/src/utils/cpi/refs.ts
+import { upgradeRoleToSigner as upgradeRoleToSigner2, upgradeRoleToWritable as upgradeRoleToWritable2 } from "@solana/kit";
+function buildIndicesForCpi(accounts, poolIndex) {
+  return accounts.map((acc) => {
+    const idx = poolIndex.get(acc.address);
+    if (idx === void 0) {
+      throw new Error(`Account ${acc.address} not found in pool`);
+    }
+    return idx;
+  });
+}
+function buildDeduplicatedPool(accountLists) {
+  const poolMap = /* @__PURE__ */ new Map();
+  for (const accounts of accountLists) {
+    for (const acc of accounts) {
+      const existing = poolMap.get(acc.address);
+      if (!existing) {
+        poolMap.set(acc.address, { ...acc });
+      } else {
+        if (isRoleWritable(acc.role) && !isRoleWritable(existing.role)) {
+          existing.role = upgradeRoleToWritable2(existing.role);
+        }
+        if (isRoleSigner(acc.role) && !isRoleSigner(existing.role)) {
+          existing.role = upgradeRoleToSigner2(existing.role);
+        }
+      }
+    }
+  }
+  return poolMap;
+}
+function buildPoolWithOrderedInitial(initialAccounts, accountLists) {
+  const pool = initialAccounts.map((acc) => ({ ...acc }));
+  const poolIndex = /* @__PURE__ */ new Map();
+  pool.forEach((acc, i) => {
+    if (!poolIndex.has(acc.address)) {
+      poolIndex.set(acc.address, i);
+    }
+  });
+  for (const accounts of accountLists) {
+    for (const acc of accounts) {
+      const existingIdx = poolIndex.get(acc.address);
+      if (existingIdx === void 0) {
+        const idx = pool.length;
+        poolIndex.set(acc.address, idx);
+        pool.push({ ...acc });
+      } else {
+        const existing = pool[existingIdx];
+        if (isRoleWritable(acc.role) && !isRoleWritable(existing.role)) {
+          existing.role = upgradeRoleToWritable2(existing.role);
+        }
+        if (isRoleSigner(acc.role) && !isRoleSigner(existing.role)) {
+          existing.role = upgradeRoleToSigner2(existing.role);
+        }
+      }
+    }
+  }
+  return { pool, poolIndex };
+}
+function buildPool(accountLists, options) {
+  if (options?.initialAccounts) {
+    return buildPoolWithOrderedInitial(options.initialAccounts, accountLists);
+  }
+  const poolMap = buildDeduplicatedPool(accountLists);
+  const pool = Array.from(poolMap.values());
+  const poolIndex = /* @__PURE__ */ new Map();
+  pool.forEach((acc, i) => poolIndex.set(acc.address, i));
+  return { pool, poolIndex };
+}
+function resolveTrackedIndices(poolIndex, trackAddresses) {
+  if (!trackAddresses) return [];
+  return trackAddresses.map((addr) => {
+    const idx = poolIndex.get(addr);
+    if (idx === void 0) {
+      throw new Error(`Tracked address ${addr} not found in pool`);
+    }
+    return idx;
+  });
+}
+function buildInstructionRefs(cpis, accountLists, poolIndex, trackedIndices) {
+  const allIndices = [];
+  const lengths = [];
+  const cpiTypes = [];
+  const cpiArgs = new CpiArgsBuilder();
+  for (let i = 0; i < cpis.length; i++) {
+    const indices = buildIndicesForCpi(accountLists[i], poolIndex);
+    allIndices.push(...indices);
+    lengths.push(indices.length);
+    cpiTypes.push(cpis[i].cpiType);
+    if (cpis[i].data !== void 0) {
+      cpiArgs.add(cpis[i].data);
+    } else {
+      cpiArgs.skip();
+    }
+  }
+  return {
+    cpi: {
+      accounts: {
+        indices: Buffer.from(allIndices),
+        lengths: Buffer.from(lengths)
+      },
+      types: Buffer.from(cpiTypes),
+      args: cpiArgs.build()
+    },
+    tracked: Buffer.from(trackedIndices)
+  };
+}
+function toCpiAccountLists(cpis) {
+  return cpis.map((cpi) => [toCustomAccountMeta(cpi.programId), ...cpi.accounts]);
+}
+function collectLookupTables(cpis) {
+  return cpis.flatMap((x) => x.lookupTables ?? []);
+}
+function createMultiCpiRefs(cpiGroups, options) {
+  const allCpis = cpiGroups.flat();
+  const allAccountLists = toCpiAccountLists(allCpis);
+  const { pool, poolIndex } = buildPool(allAccountLists, options);
+  const trackedIndices = resolveTrackedIndices(poolIndex, options?.trackAddresses);
+  let flatIdx = 0;
+  const refsGroups = cpiGroups.map((group) => {
+    const groupAccountLists = allAccountLists.slice(flatIdx, flatIdx + group.length);
+    flatIdx += group.length;
+    return buildInstructionRefs(group, groupAccountLists, poolIndex, trackedIndices);
+  });
+  return {
+    accounts: stripSignerFromAccounts(pool),
+    refsGroups,
+    lookupTables: collectLookupTables(allCpis)
+  };
+}
+function createCpiRefs(cpis, options) {
+  const accountLists = toCpiAccountLists(cpis);
+  const { pool, poolIndex } = buildPool(accountLists, options);
+  const trackedIndices = resolveTrackedIndices(poolIndex, options?.trackAddresses);
+  return {
+    accounts: stripSignerFromAccounts(pool),
+    refs: buildInstructionRefs(cpis, accountLists, poolIndex, trackedIndices),
+    lookupTables: collectLookupTables(cpis)
+  };
+}
+
+// ../../shared/common/src/utils/rpc.ts
+import {
+  createDefaultRpcTransport,
+  createSolanaRpc,
+  createSolanaRpcFromTransport
+} from "@solana/kit";
+
+// ../../shared/common/src/utils/retry.ts
+var DEFAULT_MAX_ATTEMPTS = 4;
+var INITIAL_DELAY_MS = 200;
+var MAX_DELAY_MS = 2e3;
+function isTransientNetworkError(err) {
+  if (err instanceof TypeError) return true;
+  const msg = (err?.message ?? "").toLowerCase();
+  return msg.includes("fetch failed") || msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("socket hang up") || msg.includes("network timeout") || msg.includes("all providers failed") || msg.includes("all rpc providers failed") || msg.includes("failed to get info about account") || msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("timeout") || // Local validators / forked RPCs can intermittently surface account-load
+  // issues as a generic internal JSON-RPC error before the account is warmed.
+  msg.includes("json-rpc error: internal json-rpc error") || msg.includes("json-rpc error: internal error");
+}
+function retryDelay(attempt) {
+  return Math.min(INITIAL_DELAY_MS * 2 ** attempt, MAX_DELAY_MS);
+}
+async function withNetworkRetry(fn, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
+  let lastErr;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isTransientNetworkError(err) || attempt === maxAttempts - 1) break;
+      await sleep(retryDelay(attempt));
+    }
+  }
+  throw lastErr;
+}
+function fetchWithRetry(input, init) {
+  return withNetworkRetry(() => fetch(input, init));
+}
+
+// ../../shared/common/src/utils/rpc.ts
+function createRpcWithRetry(url) {
+  const inner = createDefaultRpcTransport({ url });
+  const retryingTransport = async (...args) => withNetworkRetry(() => inner(...args));
+  return createSolanaRpcFromTransport(retryingTransport);
+}
+function createRpcWithFailover(urls) {
+  const uniqueUrls = uniqueRpcUrls(urls);
+  if (uniqueUrls.length === 0) {
+    throw new Error("createRpcWithFailover requires at least one RPC URL");
+  }
+  if (uniqueUrls.length === 1) {
+    return createRpcWithRetry(uniqueUrls[0]);
+  }
+  const providers = uniqueUrls.map((url) => ({
+    url,
+    transport: createDefaultRpcTransport({ url })
+  }));
+  const failoverTransport = async (...args) => {
+    const failures = [];
+    for (const provider of providers) {
+      try {
+        return await withNetworkRetry(() => provider.transport(...args));
+      } catch (err) {
+        if (!isTransientNetworkError(err)) {
+          throw err;
+        }
+        failures.push(
+          `${redactRpcUrlForLog(provider.url)}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    throw new Error(`All RPC providers failed: ${failures.join(" | ")}`);
+  };
+  return createSolanaRpcFromTransport(failoverTransport);
+}
+function createRpc(environment) {
+  const urls = getRpcUrls(environment);
+  if (environment === "local") return createSolanaRpc(urls[0]);
+  return createRpcWithFailover(urls);
+}
+function heliusRpcUrl(heliusApiKey) {
+  return `https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`;
+}
+function ironforgeRpcUrl(ironforgeApiKey) {
+  return `https://rpc.ironforge.network/mainnet?apiKey=${ironforgeApiKey}`;
+}
+var PUBLIC_MAINNET_RPC_URL = "https://api.mainnet-beta.solana.com";
+function getRpcUrl(environment) {
+  return getRpcUrls(environment)[0];
+}
+function getRpcUrls(environment) {
+  if (environment === "local") return ["http://127.0.0.1:8899"];
+  const urls = uniqueRpcUrls([
+    process.env.IRONFORGE_API_KEY ? ironforgeRpcUrl(process.env.IRONFORGE_API_KEY) : void 0,
+    process.env.RPC_URL,
+    process.env.HELIUS_API_KEY ? heliusRpcUrl(process.env.HELIUS_API_KEY) : void 0
+  ]);
+  if (urls.length > 0) return urls;
+  throw new Error(
+    "Non-local environment requires an RPC endpoint. Set RPC_URL, IRONFORGE_API_KEY, or HELIUS_API_KEY."
+  );
+}
+function getMainnetRpcUrl() {
+  try {
+    return getRpcUrl("prod");
+  } catch {
+    return PUBLIC_MAINNET_RPC_URL;
+  }
+}
+function redactRpcUrlForLog(url) {
+  return url.replace(/([?&]api-key=)[^&]*/gi, "$1\u2026").replace(/([?&]apiKey=)[^&]*/gi, "$1\u2026");
+}
+function uniqueRpcUrls(urls) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const url of urls) {
+    if (!url) continue;
+    const normalized = url.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    unique.push(normalized);
+  }
+  return unique;
+}
+
+// ../../shared/common/src/utils/jsonRpcFetch.ts
+var JsonRpcTransientError = class extends Error {
+  constructor(message, suggestedDelayMs) {
+    super(message);
+    this.suggestedDelayMs = suggestedDelayMs;
+    this.name = "JsonRpcTransientError";
+  }
+};
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+function parseRetryAfterMs(header) {
+  if (!header) return void 0;
+  const sec = Number(header.trim());
+  if (Number.isFinite(sec) && sec >= 0) return Math.floor(sec * 1e3);
+  return void 0;
+}
+function isRetryableJsonRpcError(err) {
+  if (!err) return false;
+  if (err.code === -32429) return true;
+  return /rate limit/i.test(err.message);
+}
+async function jsonRpcFetchOnce(rpcUrl, method, params) {
+  let res;
+  try {
+    res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+    });
+  } catch (e) {
+    const cause = e instanceof Error ? e.message : String(e);
+    const local = rpcUrl.includes("127.0.0.1") || rpcUrl.includes("localhost") ? " No process is listening on that URL \u2014 start a local validator (e.g. surfpool/solana-test-validator) or set ENVIRONMENT + RPC_URL / HELIUS_API_KEY for a remote endpoint." : "";
+    throw new JsonRpcTransientError(
+      `RPC ${method} fetch failed (${redactRpcUrlForLog(rpcUrl)}): ${cause}.${local}`
+    );
+  }
+  const retryAfterMs = parseRetryAfterMs(res.headers.get("Retry-After"));
+  if (RETRYABLE_HTTP.has(res.status)) {
+    const text = await res.text();
+    throw new JsonRpcTransientError(`RPC ${method} HTTP ${res.status}: ${text}`, retryAfterMs);
+  }
+  if (!res.ok) {
+    throw new Error(`RPC ${method} HTTP ${res.status}: ${await res.text()}`);
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new JsonRpcTransientError(`RPC ${method}: invalid JSON response body`);
+  }
+  if (body.error) {
+    const dataStr = body.error.data !== void 0 ? ` data=${JSON.stringify(body.error.data, (_, v) => typeof v === "bigint" ? v.toString() : v)}` : "";
+    if (isRetryableJsonRpcError(body.error)) {
+      throw new JsonRpcTransientError(
+        `RPC ${method} error ${body.error.code}: ${body.error.message}${dataStr}`,
+        retryAfterMs
+      );
+    }
+    throw new Error(`RPC ${method} error ${body.error.code}: ${body.error.message}${dataStr}`);
+  }
+  return body.result;
+}
+
+// ../../shared/common/src/utils/anchor.ts
+import * as anchor from "@anchor-lang/core";
+import { AnchorProvider } from "@anchor-lang/core";
+import { Connection, Keypair as Keypair2 } from "@solana/web3.js";
+var DEFAULT_COMMITMENT = "confirmed";
+function createDefaultAnchorProvider(env, walletOrKeypair, confirmOptions) {
+  const commitment = confirmOptions?.commitment ?? DEFAULT_COMMITMENT;
+  const wallet = walletOrKeypair instanceof Keypair2 ? new anchor.Wallet(walletOrKeypair) : walletOrKeypair;
+  const opts = { commitment, ...confirmOptions };
+  return new AnchorProvider(new Connection(getRpcUrl(env), commitment), wallet, opts);
+}
+function createReadOnlyAnchorProvider(env) {
+  return createDefaultAnchorProvider(env, Keypair2.generate());
+}
+
+// ../../shared/common/src/utils/transactionSplitter.ts
+import { compileTransaction, getBase64EncodedWireTransaction } from "@solana/kit";
+
+// ../../shared/common/src/utils/jito.ts
+import { getTransferSolInstruction as getTransferSolInstruction2 } from "@solana-program/system";
+var MAX_BUNDLE_TRANSACTIONS = 5;
+var DEFAULT_JITO_TIP_LAMPORTS = 2e6;
+var JitoBundleError = class extends Error {
+  constructor(message, bundleId) {
+    super(message);
+    this.bundleId = bundleId;
+    this.name = "JitoBundleError";
+  }
+};
+var JITO_TIP_ACCOUNTS = [
+  "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+  "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"
+];
+var BUNDLE_INJECTED_IX_RESERVED_BYTES = 64;
+function getRandomTipAccount() {
+  return JITO_TIP_ACCOUNTS[Math.floor(Math.random() * JITO_TIP_ACCOUNTS.length)];
+}
+function buildTipInstruction(payer, tipAccount, lamports) {
+  return getTransferSolInstruction2({
+    source: payer,
+    destination: tipAccount,
+    amount: BigInt(lamports)
+  });
+}
+async function sendBundle(rpcUrl, base64Txs) {
+  if (base64Txs.length > MAX_BUNDLE_TRANSACTIONS) {
+    throw new JitoBundleError(
+      `Bundle has ${base64Txs.length} transactions, max is ${MAX_BUNDLE_TRANSACTIONS}`
+    );
+  }
+  try {
+    return await jsonRpcFetchOnce(rpcUrl, "sendBundle", [
+      base64Txs,
+      { encoding: "base64" }
+    ]);
+  } catch (e) {
+    throw new JitoBundleError(`sendBundle failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+async function simulateBundle(rpcUrl, base64Txs, options = {}) {
+  const { skipSigVerify = true, replaceRecentBlockhash = true } = options;
+  if (base64Txs.length > MAX_BUNDLE_TRANSACTIONS) {
+    throw new JitoBundleError(
+      `Bundle has ${base64Txs.length} transactions, max is ${MAX_BUNDLE_TRANSACTIONS}`
+    );
+  }
+  try {
+    const accountsConfigs = base64Txs.map(() => null);
+    const raw = await jsonRpcFetchOnce(rpcUrl, "simulateBundle", [
+      { encodedTransactions: base64Txs },
+      {
+        preExecutionAccountsConfigs: accountsConfigs,
+        postExecutionAccountsConfigs: accountsConfigs,
+        skipSigVerify,
+        replaceRecentBlockhash,
+        transactionEncoding: "base64"
+      }
+    ]);
+    return "value" in raw && raw.value ? raw.value : raw;
+  } catch (e) {
+    throw new JitoBundleError(
+      `simulateBundle failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+async function confirmBundle(rpcUrl, bundleId, timeoutMs = 6e4) {
+  const pollIntervalMs = 1e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    await sleep(pollIntervalMs);
+    let result;
+    try {
+      result = await jsonRpcFetchOnce(
+        rpcUrl,
+        "getBundleStatuses",
+        [[bundleId]]
+      );
+    } catch (e) {
+      console.warn(`[Jito] getBundleStatuses error: ${e instanceof Error ? e.message : String(e)}`);
+      continue;
+    }
+    const entry = result.value?.[0];
+    if (!entry) continue;
+    if (entry.err != null && "Err" in entry.err) {
+      throw new JitoBundleError(
+        `Bundle ${bundleId} failed: ${JSON.stringify(entry.err)}`,
+        bundleId
+      );
+    }
+    if (entry.confirmation_status === "confirmed" || entry.confirmation_status === "finalized") {
+      return { slot: entry.slot };
+    }
+  }
+  throw new JitoBundleError(
+    `Bundle ${bundleId} confirmation timeout after ${timeoutMs}ms`,
+    bundleId
+  );
+}
+
+// ../../shared/common/src/utils/transactionSplitter.ts
+var SOLANA_TX_SIZE_LIMIT = 1232;
+function measureTxBytes(msg) {
+  const compiled = compileTransaction(msg);
+  const b64 = getBase64EncodedWireTransaction(compiled);
+  return Math.ceil(b64.length * 3 / 4);
+}
+function buildInstructionSegments(instructions, segmentLengths) {
+  if (segmentLengths === void 0 || segmentLengths.length === 0) {
+    return instructions.map((ix) => [ix]);
+  }
+  const sum2 = segmentLengths.reduce((a, b) => a + b, 0);
+  if (sum2 !== instructions.length) {
+    throw new Error(
+      `segmentLengths sum (${sum2}) must equal instructions.length (${instructions.length}).`
+    );
+  }
+  if (segmentLengths.some((n) => !Number.isInteger(n) || n <= 0)) {
+    throw new Error("segmentLengths entries must be positive integers.");
+  }
+  const segments = [];
+  let offset = 0;
+  for (const len of segmentLengths) {
+    segments.push(instructions.slice(offset, offset + len));
+    offset += len;
+  }
+  return segments;
+}
+async function splitIntoTransactionBins(rpc, payer, instructions, options = {}) {
+  const {
+    lookupTables,
+    additionalSigners,
+    blockhash,
+    reservedBytes = 0,
+    segmentLengths,
+    freshBinSegments
+  } = options;
+  const effectiveLimit = SOLANA_TX_SIZE_LIMIT - reservedBytes;
+  const freshBinSet = freshBinSegments ? new Set(freshBinSegments) : void 0;
+  if (effectiveLimit <= 0) {
+    throw new Error(
+      `reservedBytes (${reservedBytes}) is >= the tx size limit (${SOLANA_TX_SIZE_LIMIT}).`
+    );
+  }
+  const segments = buildInstructionSegments(instructions, segmentLengths);
+  const bins = [];
+  let currentBin = [];
+  const measureCandidate = async (candidate) => {
+    const msg = await buildTransactionMessage(
+      rpc,
+      payer,
+      candidate,
+      lookupTables,
+      additionalSigners,
+      blockhash
+    );
+    return measureTxBytes(msg);
+  };
+  for (let segIdx = 0; segIdx < segments.length; segIdx += 1) {
+    const segment = segments[segIdx];
+    if (freshBinSet?.has(segIdx) && currentBin.length > 0) {
+      bins.push(currentBin);
+      currentBin = [];
+    }
+    const candidate = [...currentBin, ...segment];
+    const size = await measureCandidate(candidate);
+    if (size <= effectiveLimit) {
+      currentBin = candidate;
+      continue;
+    }
+    if (currentBin.length === 0) {
+      throw new Error(
+        `An indivisible instruction group (${segment.length} instruction(s)) measures ${size} bytes, exceeding the ${effectiveLimit}-byte effective tx size limit (${SOLANA_TX_SIZE_LIMIT} - ${reservedBytes} reserved) even with address lookup tables. Cannot split.`
+      );
+    }
+    bins.push(currentBin);
+    currentBin = [...segment];
+    const segmentSize = await measureCandidate(currentBin);
+    if (segmentSize > effectiveLimit) {
+      throw new Error(
+        `An indivisible instruction group (${segment.length} instruction(s)) measures ${segmentSize} bytes, exceeding the ${effectiveLimit}-byte effective tx size limit (${SOLANA_TX_SIZE_LIMIT} - ${reservedBytes} reserved) even with address lookup tables. Cannot split.`
+      );
+    }
+  }
+  if (currentBin.length > 0) {
+    bins.push(currentBin);
+  }
+  if (bins.length > MAX_BUNDLE_TRANSACTIONS) {
+    throw new Error(
+      `Instruction list requires ${bins.length} transactions, but Jito bundles allow at most ${MAX_BUNDLE_TRANSACTIONS}.`
+    );
+  }
+  return { bins };
+}
+
+// ../../shared/common/src/utils/txAccountCoverage.ts
+import { compileTransaction as compileTransaction2, getCompiledTransactionMessageDecoder } from "@solana/kit";
+
+// ../../shared/common/src/utils/token.ts
+import { address as address4 } from "@solana/kit";
+import { BN as BN2 } from "@anchor-lang/core";
+import {
+  getInitializeMint2Instruction,
+  getMintSize,
+  TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS4
+} from "@solana-program/token";
+import { TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS2 } from "@solana-program/token-2022";
+import { getCreateAccountInstruction } from "@solana-program/system";
+
+// ../../shared/common/src/types/enums.ts
+function enumToOracleType(t) {
+  switch (t) {
+    case 0 /* Pyth */:
+      return { pyth: {} };
+    case 1 /* Switchboard */:
+      return { switchboard: {} };
+    case 2 /* PerenaBank */:
+      return { perenaBank: {} };
+    case 3 /* PerenaTranche */:
+      return { perenaTranche: {} };
+    case 4 /* PythSplStake */:
+      return { pythSplStake: {} };
+    case 5 /* TPConsensusOracle */:
+      return { tpConsensusOracle: {} };
+  }
+}
+function ExternalLiquidityTypeToEnum(v) {
+  if ("none" in v) return 0 /* None */;
+  if ("perenaWithdrawalQueue" in v) return 1 /* PerenaWithdrawalQueue */;
+  throw new Error("Unknown ExternalLiquidityType variant");
+}
+function enumToExternalLiquidityType(t) {
+  switch (t) {
+    case 0 /* None */:
+      return { none: {} };
+    case 1 /* PerenaWithdrawalQueue */:
+      return { perenaWithdrawalQueue: {} };
+  }
+}
+function tokenProgramToEnum(v) {
+  if ("spl" in v) return 0 /* Spl */;
+  if ("token2022" in v) return 1 /* Token2022 */;
+  throw new Error("Unknown TokenProgram variant");
+}
+function enumToTokenProgram(t) {
+  switch (t) {
+    case 0 /* Spl */:
+      return { spl: {} };
+    case 1 /* Token2022 */:
+      return { token2022: {} };
+  }
+}
+function lendingPlatformToEnum(v) {
+  if ("none" in v) return 0 /* None */;
+  if ("marginfi" in v) return 1 /* Marginfi */;
+  if ("kamino" in v) return 2 /* Kamino */;
+  throw new Error("Unknown LendingPlatform variant");
+}
+function enumToLendingPlatform(t) {
+  switch (t) {
+    case 0 /* None */:
+      return { none: {} };
+    case 1 /* Marginfi */:
+      return { marginfi: {} };
+    case 2 /* Kamino */:
+      return { kamino: {} };
+  }
+}
+
+// ../../shared/common/src/utils/token.ts
+function resolveTokenProgram(tp) {
+  return tokenProgramToEnum(tp) === 0 /* Spl */ ? TOKEN_PROGRAM_ADDRESS4 : TOKEN_2022_PROGRAM_ADDRESS2;
+}
+async function getCreateMintInstructions(rpc, payer, mintSigner, authority, decimals, tokenProgram = TOKEN_PROGRAM_ADDRESS4) {
+  const space = getMintSize();
+  const rent = await rpc.getMinimumBalanceForRentExemption(BigInt(space)).send();
+  return [
+    getCreateAccountInstruction({
+      payer,
+      newAccount: mintSigner,
+      lamports: rent,
+      space,
+      programAddress: tokenProgram
+    }),
+    getInitializeMint2Instruction({
+      mint: mintSigner.address,
+      decimals,
+      mintAuthority: authority
+    })
+  ];
+}
+async function createMint(rpc, payer, mintSigner, authority, decimals, tokenProgram = TOKEN_PROGRAM_ADDRESS4) {
+  const instructions = await getCreateMintInstructions(
+    rpc,
+    payer,
+    mintSigner,
+    authority,
+    decimals,
+    tokenProgram
+  );
+  await signSendAndConfirmTransaction(rpc, payer, instructions, {
+    additionalSigners: [mintSigner]
+  });
+}
+
+// ../../shared/common/src/utils/metadata.ts
+import {
+  AccountRole as AccountRole3,
+  getAddressEncoder,
+  getProgramDerivedAddress
+} from "@solana/kit";
+import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
+import { SYSVAR_RENT_ADDRESS } from "@solana/sysvars";
+import {
+  createUpdateMetadataAccountV2Instruction,
+  createCreateMetadataAccountV3Instruction,
+  Metadata
+} from "@metaplex-foundation/mpl-token-metadata";
+
+// ../../shared/common/src/constants/generated/cpi.ts
+var CpiTypes = {
+  JUPITER_SWAP: 0,
+  PERENA_MINT: 1,
+  PERENA_BURN: 2,
+  PERENA_STAKE: 3,
+  PERENA_INSTANT_UNSTAKE: 4,
+  PERENA_REQUEST_UNSTAKE: 5,
+  PERENA_FULFILL_UNSTAKE: 6,
+  K_INIT_USER_METADATA: 7,
+  K_INIT_OBLIGATION: 8,
+  K_INIT_USER_FARM: 9,
+  K_REFRESH_RESERVE: 10,
+  K_REFRESH_OBLIGATION: 11,
+  K_REFRESH_USER_FARM: 12,
+  K_HARVEST_REWARD: 13,
+  K_REQUEST_ELEVATION_GROUP: 14,
+  K_DEPOSIT: 15,
+  K_WITHDRAW: 16,
+  K_BORROW: 17,
+  K_REPAY: 18,
+  MPL_UPDATE_METADATA: 19,
+  MPL_CREATE_METADATA: 20
+};
+
+// ../../shared/common/src/utils/metadata.ts
+var addressEncoder = getAddressEncoder();
+
+// ../../shared/common/src/utils/priorityFee.ts
+import bs58 from "bs58";
+var MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 1e8;
+function normalizeEstimate(result) {
+  const estimate = result.priorityFeeEstimate;
+  if (typeof estimate === "bigint") {
+    if (estimate < 0n) {
+      throw new Error("Helius getPriorityFeeEstimate returned an invalid estimate");
+    }
+    return Number(
+      estimate > BigInt(MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS) ? BigInt(MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS) : estimate
+    );
+  }
+  if (estimate === void 0 || !Number.isFinite(estimate) || estimate < 0) {
+    throw new Error("Helius getPriorityFeeEstimate returned an invalid estimate");
+  }
+  return Math.min(Math.round(estimate), MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS);
+}
+async function getPriorityFeeEstimate(rpc, transaction, accountKeys, priorityFeeSetting) {
+  const transactionBase58 = bs58.encode(Buffer.from(transaction, "base64"));
+  const priorityFeeRpc = rpc;
+  try {
+    const result = await priorityFeeRpc.getPriorityFeeEstimate({
+      transaction: transactionBase58,
+      options: { priorityLevel: priorityFeeSetting }
+    }).send();
+    return normalizeEstimate(result);
+  } catch {
+    const result = await priorityFeeRpc.getPriorityFeeEstimate({
+      accountKeys,
+      options: { priorityLevel: priorityFeeSetting }
+    }).send();
+    return normalizeEstimate(result);
+  }
+}
+
+// ../../shared/common/src/constants/accountMetas.ts
+import { SYSVAR_INSTRUCTIONS_ADDRESS, SYSVAR_RENT_ADDRESS as SYSVAR_RENT_ADDRESS2 } from "@solana/sysvars";
+import { SYSTEM_PROGRAM_ADDRESS as SYSTEM_PROGRAM_ADDRESS2 } from "@solana-program/system";
+var RENT_SYSVAR_META = toCustomAccountMeta(SYSVAR_RENT_ADDRESS2);
+var SYSTEM_PROGRAM_META = toCustomAccountMeta(SYSTEM_PROGRAM_ADDRESS2);
+var IX_SYSVAR_META = toCustomAccountMeta(SYSVAR_INSTRUCTIONS_ADDRESS);
+
+// ../../shared/common/src/services/lutManager.ts
+var LUT_CACHE_CATEGORY = "lookupTable";
+var LutManager = class {
+  constructor(cacheTtlConfig) {
+    this.cache = new DataCache({
+      defaultTtlMs: cacheTtlConfig?.defaultTtlMs ?? 6e4 * 15,
+      categoryTtlMs: cacheTtlConfig?.categoryTtlMs
+    });
+  }
+  /**
+   * Fetch a single lookup table's data, with caching.
+   */
+  async fetchLookupTable(rpc, address9) {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => {
+        const table = await fetchAddressLookupTable(rpc, address9);
+        return {
+          address: address9,
+          addresses: table.data.addresses
+        };
+      },
+      LUT_CACHE_CATEGORY,
+      address9
+    );
+    return data;
+  }
+  /**
+   * Fetch address lookup table data for the given addresses, with caching.
+   */
+  async getLookupTableInputs(rpc, lookupTableAddresses) {
+    return Promise.all(lookupTableAddresses.map((address9) => this.fetchLookupTable(rpc, address9)));
+  }
+  async addAddressesIfNeeded(signer, rpc, lookupTableAddress, existingAddresses, addressesToAdd) {
+    const existingSet = new Set(existingAddresses);
+    const addresses = addressesToAdd.filter((x) => !existingSet.has(x));
+    if (addresses.length > 0) {
+      const batches = getBatches(addresses, 20);
+      for (const addressBatch of batches) {
+        const extendIx = getExtendLookupTableInstruction({
+          address: lookupTableAddress,
+          authority: signer,
+          payer: signer,
+          addresses: addressBatch
+        });
+        await signSendAndConfirmTransaction(rpc, signer, [extendIx]);
+      }
+    }
+  }
+  async deriveLookupTableAddress(signerAddress, recentSlot) {
+    const addressEncoder2 = getAddressEncoder2();
+    const u64Encoder = getU64Encoder();
+    return await getProgramDerivedAddress2({
+      programAddress: ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS,
+      seeds: [addressEncoder2.encode(signerAddress), u64Encoder.encode(recentSlot)]
+    });
+  }
+  async updateLookupTable(signer, rpc, accounts, existingLookupTableAddress) {
+    if (existingLookupTableAddress === DEFAULT_PUBLIC_KEY) {
+      existingLookupTableAddress = void 0;
+    }
+    let lookupTableAddress;
+    let existingAccounts;
+    if (existingLookupTableAddress) {
+      lookupTableAddress = existingLookupTableAddress;
+      const lutInput = await this.fetchLookupTable(rpc, lookupTableAddress);
+      existingAccounts = lutInput.addresses;
+    } else {
+      const maxAttempts = 3;
+      let lastError;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const slot = await getSlot(rpc, "finalized");
+        const lutPda = await this.deriveLookupTableAddress(signer.address, slot);
+        const createLutIx = getCreateLookupTableInstruction({
+          address: lutPda,
+          authority: signer,
+          recentSlot: slot
+        });
+        try {
+          await signSendAndConfirmTransaction(rpc, signer, [createLutIx], {
+            hideFailureInfo: attempt < maxAttempts
+          });
+          lookupTableAddress = lutPda[0];
+          console.log(`Created new lookup table: ${lookupTableAddress}`);
+          this.cache.setCache(LUT_CACHE_CATEGORY, lookupTableAddress, {
+            address: lookupTableAddress,
+            addresses: []
+          });
+          lastError = void 0;
+          break;
+        } catch (e) {
+          lastError = e;
+          const errorStr = String(e);
+          const logsStr = e instanceof TransactionError ? e.programLogs.join("\n") : "";
+          const isStaleSlot = errorStr.includes("is not a recent slot") || logsStr.includes("is not a recent slot");
+          if (isStaleSlot && attempt < maxAttempts) {
+            console.warn(
+              `LUT creation failed (stale slot ${slot}), retrying (${attempt}/${maxAttempts})...`
+            );
+            await new Promise((r) => setTimeout(r, 2e3));
+            continue;
+          }
+          throw e;
+        }
+      }
+      if (lastError) throw lastError;
+      lookupTableAddress = lookupTableAddress;
+      existingAccounts = [];
+    }
+    await this.addAddressesIfNeeded(
+      signer,
+      rpc,
+      lookupTableAddress,
+      existingAccounts,
+      deduplicateAccounts(accounts).filter((x) => x !== DEFAULT_PUBLIC_KEY)
+    );
+    this.clearLookupTableCache(lookupTableAddress);
+    return lookupTableAddress;
+  }
+  /**
+   * Clear all cached lookup table data.
+   */
+  clearCache() {
+    this.cache.clearAllCache();
+  }
+  /**
+   * Clear cached data for a specific lookup table.
+   */
+  clearLookupTableCache(address9) {
+    this.cache.clearCacheEntry(LUT_CACHE_CATEGORY, address9);
+  }
+};
+var lutManager = new LutManager();
+
+// ../../shared/common/src/utils/transaction.ts
+var MAX_COMPUTE_UNIT_LIMIT = 14e5;
+var DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER = 1.1;
+function computeUnitLimitFromSimulation(unitsConsumed, multiplier = DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER) {
+  if (!(unitsConsumed > 0) || !(multiplier > 0)) {
+    return MAX_COMPUTE_UNIT_LIMIT;
+  }
+  return Math.min(MAX_COMPUTE_UNIT_LIMIT, Math.ceil(unitsConsumed * multiplier));
+}
+function collectWritableAccounts(instructions) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const ix of instructions) {
+    for (const acc of ix.accounts ?? []) {
+      const role = acc.role;
+      if (role != null && (role & 1) === 1) {
+        const addr = acc.address;
+        if (!seen.has(addr)) {
+          seen.add(addr);
+          out.push(addr);
+        }
+      }
+    }
+  }
+  return out;
+}
+async function signTransactionsWithSigners(transactions, signers) {
+  let signedTransactions = [...transactions];
+  const modifyingSigners = signers.filter(isTransactionModifyingSigner);
+  const partialSigners = signers.filter(isTransactionPartialSigner);
+  for (const signer of modifyingSigners) {
+    signedTransactions = [...await signer.modifyAndSignTransactions(signedTransactions)];
+  }
+  for (const signer of partialSigners) {
+    const signatures = await signer.signTransactions(signedTransactions);
+    signedTransactions = signedTransactions.map((transaction, index) => ({
+      ...transaction,
+      signatures: {
+        ...transaction.signatures,
+        ...signatures[index]
+      }
+    }));
+  }
+  for (const transaction of signedTransactions) {
+    assertIsFullySignedTransaction(transaction);
+  }
+  return signedTransactions;
+}
+var TransactionError = class extends Error {
+  constructor(message, programLogs = []) {
+    super(programLogs.length ? `${message}
+
+Program logs:
+${programLogs.join("\n")}` : message);
+    this.name = "TransactionError";
+    this.programLogs = programLogs;
+  }
+};
+function logProgramLogsLineByLine(logs, label = "Program logs") {
+  if (!logs.length) {
+    console.error(`${label}: (no logs returned)`);
+    return;
+  }
+  console.error(`${label} (${logs.length} lines):`);
+  logs.forEach((line, index) => {
+    console.error(`[${index}] ${line}`);
+  });
+}
+async function resolvePriorityFeeMicroLamports(rpc, transactionMessage, writableAccounts, options) {
+  if (options?.computeUnitPriceMicroLamports !== void 0) {
+    return options.computeUnitPriceMicroLamports;
+  }
+  if (options?.priorityFeeSetting === void 0) {
+    return void 0;
+  }
+  const estimateMessage = appendTransactionMessageInstructions(
+    [setComputeUnitLimitIx(MAX_COMPUTE_UNIT_LIMIT)],
+    transactionMessage
+  );
+  const estimateTransaction = getBase64EncodedWireTransaction2(compileTransaction3(estimateMessage));
+  return getPriorityFeeEstimate(
+    rpc,
+    estimateTransaction,
+    writableAccounts,
+    options.priorityFeeSetting
+  );
+}
+function getComputeBudgetInstructions(computeUnitLimit, priorityFeeMicroLamports) {
+  return priorityFeeMicroLamports === void 0 ? [setComputeUnitLimitIx(computeUnitLimit)] : [setComputeUnitPriceIx(priorityFeeMicroLamports), setComputeUnitLimitIx(computeUnitLimit)];
+}
+async function buildTransactionMessage(rpc, feePayer, instructions, lookupTableAddresses, additionalSigners, blockhash) {
+  const blockhashInfo = blockhash ?? (await rpc.getLatestBlockhash({ commitment: "confirmed" }).send()).value;
+  let transactionMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(feePayer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhashInfo, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx)
+  );
+  const allSigners = [feePayer, ...additionalSigners ?? []];
+  transactionMessage = addSignersToTransactionMessage(allSigners, transactionMessage);
+  if (lookupTableAddresses?.length) {
+    const lutInputs = await lutManager.getLookupTableInputs(
+      rpc,
+      deduplicateAccounts(lookupTableAddresses)
+    );
+    const lookupTables = {};
+    for (const lut of lutInputs) {
+      lookupTables[lut.address] = [...lut.addresses];
+    }
+    transactionMessage = compressTransactionMessageUsingAddressLookupTables(
+      transactionMessage,
+      lookupTables
+    );
+  }
+  return transactionMessage;
+}
+async function simulateTransaction(rpc, transactionMessage) {
+  const compiledTransaction = compileTransaction3(transactionMessage);
+  const base64EncodedTransaction = getBase64EncodedWireTransaction2(compiledTransaction);
+  const {
+    value: { err, logs, unitsConsumed }
+  } = await rpc.simulateTransaction(base64EncodedTransaction, {
+    encoding: "base64",
+    sigVerify: false,
+    replaceRecentBlockhash: false,
+    commitment: "confirmed"
+  }).send();
+  return {
+    err,
+    logs: logs ?? [],
+    unitsConsumed: unitsConsumed ?? 0n
+  };
+}
+async function signSendAndConfirmTransaction(rpc, payer, instructionsOrPlan, options) {
+  const instructions = Array.isArray(instructionsOrPlan) ? instructionsOrPlan : instructionsOrPlan.instructions;
+  const lookupTables = Array.isArray(instructionsOrPlan) ? options?.lookupTables : options?.lookupTables ?? instructionsOrPlan.lookupTables;
+  const segmentLengths = Array.isArray(instructionsOrPlan) ? void 0 : instructionsOrPlan.segmentLengths;
+  const freshBinSegments = Array.isArray(instructionsOrPlan) ? void 0 : instructionsOrPlan.freshBinSegments;
+  const filteredLuts = lookupTables?.filter((x) => x !== DEFAULT_PUBLIC_KEY);
+  const transactionMessage = await buildTransactionMessage(
+    rpc,
+    payer,
+    instructions,
+    filteredLuts,
+    options?.additionalSigners
+  );
+  const txBytes = measureTxBytes(transactionMessage);
+  const maxUnaugmentedTxBytes = SOLANA_TX_SIZE_LIMIT - BUNDLE_INJECTED_IX_RESERVED_BYTES;
+  const mustSplit = txBytes > maxUnaugmentedTxBytes || options?.forceJitoBundle || !!freshBinSegments?.length;
+  if (mustSplit) {
+    if (options?.sendOversizedAsSequentialTransactions) {
+      return signSendAndConfirmSplitSequentially(
+        rpc,
+        payer,
+        instructions,
+        filteredLuts,
+        options,
+        segmentLengths,
+        freshBinSegments
+      );
+    }
+    return _signSendAndConfirmBundle(
+      rpc,
+      payer,
+      instructions,
+      filteredLuts,
+      options,
+      segmentLengths,
+      freshBinSegments
+    );
+  }
+  const writableAccounts = collectWritableAccounts(instructions);
+  const priorityFeeMicroLamports = await resolvePriorityFeeMicroLamports(
+    rpc,
+    transactionMessage,
+    writableAccounts,
+    options
+  );
+  const simMessage = appendTransactionMessageInstructions(
+    getComputeBudgetInstructions(MAX_COMPUTE_UNIT_LIMIT, priorityFeeMicroLamports),
+    transactionMessage
+  );
+  const simulation = await simulateTransaction(rpc, simMessage);
+  if (simulation.err) {
+    if (!options?.hideFailureInfo) {
+      console.error("Simulation failed:", simulation.err);
+      logProgramLogsLineByLine(simulation.logs, "Simulation logs");
+    }
+    const errStr = JSON.stringify(
+      simulation.err,
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+    throw new TransactionError(`Transaction simulation failed: ${errStr}`, simulation.logs);
+  }
+  const computeUnits = computeUnitLimitFromSimulation(
+    Number(simulation.unitsConsumed),
+    options?.computeUnitLimitMultiplier ?? DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER
+  );
+  const finalMessage = appendTransactionMessageInstructions(
+    getComputeBudgetInstructions(computeUnits, priorityFeeMicroLamports),
+    transactionMessage
+  );
+  const signedTx = await signTransactionMessageWithSigners(
+    finalMessage
+  );
+  const base64EncodedTransaction = getBase64EncodedWireTransaction2(signedTx);
+  const signature = getSignatureFromTransaction(signedTx);
+  await rpc.sendTransaction(base64EncodedTransaction, {
+    encoding: "base64",
+    skipPreflight: true
+  }).send();
+  try {
+    await confirmTransaction(rpc, signature, "confirmed");
+    options?.onSuccess?.();
+    return signature;
+  } catch (error) {
+    let logs = [];
+    let landedSuccessfully = false;
+    try {
+      const info = await rpc.getTransaction(signature, { commitment: "confirmed", encoding: "base64" }).send();
+      if (info) {
+        logs = info.meta?.logMessages ?? [];
+        if (info.meta?.err == null) {
+          landedSuccessfully = true;
+        }
+      }
+    } catch {
+    }
+    if (landedSuccessfully) {
+      console.warn(
+        `Confirmation polling failed for signature ${signature} but the transaction landed on-chain; treating as success. Reason: ${error instanceof Error ? error.message : String(error)}`
+      );
+      options?.onSuccess?.();
+      return signature;
+    }
+    if (!options?.hideFailureInfo) {
+      console.error("Transaction failed:", error);
+      logProgramLogsLineByLine(logs, "Transaction logs");
+    }
+    throw new TransactionError(`Transaction failed: ${error}`, logs);
+  }
+}
+async function signSplitBin(rpc, payer, bin, lookupTables, additionalSigners, blockhash, priorityFeeMicroLamports) {
+  const msg = await buildTransactionMessage(
+    rpc,
+    payer,
+    bin,
+    lookupTables,
+    additionalSigners,
+    blockhash
+  );
+  const finalMsg = appendTransactionMessageInstructions(
+    getComputeBudgetInstructions(MAX_COMPUTE_UNIT_LIMIT, priorityFeeMicroLamports),
+    msg
+  );
+  const signed = await signTransactionMessageWithSigners(finalMsg);
+  return {
+    wireB64: getBase64EncodedWireTransaction2(signed),
+    signature: getSignatureFromTransaction(signed)
+  };
+}
+async function _signSendAndConfirmBundle(rpc, payer, instructions, lookupTables, options, segmentLengths, freshBinSegments) {
+  const tipLamports = options?.jitoTipLamports ?? DEFAULT_JITO_TIP_LAMPORTS;
+  if (tipLamports === 0) {
+    throw new TransactionError(
+      "Transaction exceeds the Solana size limit and Jito bundling is disabled. Set jitoTipLamports > 0 to enable bundle fallback."
+    );
+  }
+  const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+  const { bins } = await splitIntoTransactionBins(rpc, payer, instructions, {
+    lookupTables,
+    additionalSigners: options?.additionalSigners,
+    blockhash,
+    reservedBytes: BUNDLE_INJECTED_IX_RESERVED_BYTES,
+    segmentLengths,
+    freshBinSegments
+  });
+  if (bins.length === 0) {
+    throw new TransactionError("Bundle build produced 0 bins; cannot attach Jito tip.");
+  }
+  const messages = [];
+  for (const bin of bins) {
+    messages.push(
+      await buildTransactionMessage(
+        rpc,
+        payer,
+        bin,
+        lookupTables,
+        options?.additionalSigners,
+        blockhash
+      )
+    );
+  }
+  const tipBinIdx = messages.map((m, i) => ({ i, bytes: measureTxBytes(m) })).reduce((a, b) => a.bytes <= b.bytes ? a : b).i;
+  const tipAccount = getRandomTipAccount();
+  const tipIx = buildTipInstruction(payer, tipAccount, tipLamports);
+  messages[tipBinIdx] = appendTransactionMessageInstructions(
+    [tipIx],
+    messages[tipBinIdx]
+  );
+  console.log(
+    `[bundle] attached ${tipLamports} lamport tip to tx[${tipBinIdx}] (smallest of ${messages.length}) \u2192 ${tipAccount}`
+  );
+  const priorityFeeMicroLamports = await Promise.all(
+    messages.map(
+      (message, index) => resolvePriorityFeeMicroLamports(rpc, message, collectWritableAccounts(bins[index]), options)
+    )
+  );
+  const simEncodedTxs = [];
+  for (let i = 0; i < messages.length; i += 1) {
+    const simMsg = appendTransactionMessageInstructions(
+      getComputeBudgetInstructions(MAX_COMPUTE_UNIT_LIMIT, priorityFeeMicroLamports[i]),
+      messages[i]
+    );
+    const compiled = compileTransaction3(simMsg);
+    simEncodedTxs.push(getBase64EncodedWireTransaction2(compiled));
+  }
+  const rpcUrl = getMainnetRpcUrl();
+  const simResult = await simulateBundle(rpcUrl, simEncodedTxs, {
+    replaceRecentBlockhash: false
+  });
+  const failingIdx = simResult.transactionResults.findIndex((r) => r.err != null);
+  if (simResult.summary !== "succeeded" || failingIdx >= 0) {
+    const idx = failingIdx >= 0 ? failingIdx : 0;
+    const failed = simResult.transactionResults[idx];
+    if (!options?.hideFailureInfo) {
+      console.error(`Bundle simulation failed at tx[${idx}] of ${bins.length}.`);
+      console.error("Summary:", JSON.stringify(simResult.summary, null, 2));
+      simResult.transactionResults.forEach((r, i) => {
+        const tag = i === idx ? "  \u2190 FAILED" : i < idx ? "  (succeeded)" : "  (not run)";
+        console.error(`
+\u2500\u2500 tx[${i}]${tag} (unitsConsumed=${r.unitsConsumed ?? "\u2014"}) \u2500\u2500`);
+        if (r.err != null) console.error("  err:", JSON.stringify(r.err));
+        logProgramLogsLineByLine(r.logs ?? [], `tx[${i}] bundle simulation logs`);
+      });
+      try {
+        const failedSimMsg = appendTransactionMessageInstructions(
+          getComputeBudgetInstructions(MAX_COMPUTE_UNIT_LIMIT, priorityFeeMicroLamports[idx]),
+          messages[idx]
+        );
+        const failedB64 = getBase64EncodedWireTransaction2(compileTransaction3(failedSimMsg));
+        const standalone = await jsonRpcFetchOnce(rpcUrl, "simulateTransaction", [
+          failedB64,
+          {
+            encoding: "base64",
+            sigVerify: false,
+            replaceRecentBlockhash: false,
+            commitment: "confirmed"
+          }
+        ]);
+        console.error(
+          `
+\u2500\u2500 tx[${idx}] standalone simulateTransaction (full logs, no preceding-bin effects) \u2500\u2500`
+        );
+        if (standalone.value.err != null)
+          console.error(
+            "  err:",
+            JSON.stringify(
+              standalone.value.err,
+              (_, v) => typeof v === "bigint" ? v.toString() : v
+            )
+          );
+        const logs = standalone.value.logs ?? [];
+        logProgramLogsLineByLine(logs, `tx[${idx}] standalone simulation logs`);
+      } catch (err) {
+        console.error(
+          "  (standalone fallback failed:",
+          err instanceof Error ? err.message : String(err),
+          ")"
+        );
+      }
+    }
+    const errStr = JSON.stringify(
+      failed?.err ?? simResult.summary,
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+    throw new TransactionError(
+      `Bundle simulation failed at tx[${idx}]: ${errStr}`,
+      failed?.logs ?? []
+    );
+  }
+  const finalTransactions = [];
+  for (let i = 0; i < messages.length; i += 1) {
+    const measured = simResult.transactionResults[i]?.unitsConsumed;
+    const cu = measured && measured > 0 ? Math.ceil(measured * 1.1) : MAX_COMPUTE_UNIT_LIMIT;
+    const withCu = appendTransactionMessageInstructions(
+      getComputeBudgetInstructions(cu, priorityFeeMicroLamports[i]),
+      messages[i]
+    );
+    const finalMsg = setTransactionMessageLifetimeUsingBlockhash(
+      blockhash,
+      withCu
+    );
+    finalTransactions.push(compileTransaction3(finalMsg));
+  }
+  const signedTransactions = await signTransactionsWithSigners(finalTransactions, [
+    payer,
+    ...options?.additionalSigners ?? []
+  ]);
+  const base64Txs = signedTransactions.map(getBase64EncodedWireTransaction2);
+  const lastSignature = getSignatureFromTransaction(
+    signedTransactions[signedTransactions.length - 1]
+  );
+  try {
+    console.log(`[bundle] sending via ${redactRpcUrlForLog(rpcUrl)}`);
+    const bundleId = await sendBundle(rpcUrl, base64Txs);
+    await confirmBundle(rpcUrl, bundleId);
+    options?.onSuccess?.();
+    return lastSignature;
+  } catch (error) {
+    if (error instanceof JitoBundleError) {
+      throw new TransactionError(`Jito bundle failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function signSendAndConfirmSplitSequentially(rpc, payer, instructions, lookupTables, options, segmentLengths, freshBinSegments) {
+  const { value: splitBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+  const { bins } = await splitIntoTransactionBins(rpc, payer, instructions, {
+    lookupTables,
+    additionalSigners: options?.additionalSigners,
+    blockhash: splitBlockhash,
+    reservedBytes: BUNDLE_INJECTED_IX_RESERVED_BYTES,
+    segmentLengths,
+    freshBinSegments
+  });
+  let lastSignature;
+  for (const [binIndex, bin] of bins.entries()) {
+    const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+    const transactionMessage = await buildTransactionMessage(
+      rpc,
+      payer,
+      bin,
+      lookupTables,
+      options?.additionalSigners,
+      blockhash
+    );
+    const priorityFeeMicroLamports = await resolvePriorityFeeMicroLamports(
+      rpc,
+      transactionMessage,
+      collectWritableAccounts(bin),
+      options
+    );
+    const simMsg = appendTransactionMessageInstructions(
+      getComputeBudgetInstructions(MAX_COMPUTE_UNIT_LIMIT, priorityFeeMicroLamports),
+      transactionMessage
+    );
+    const simulation = await simulateTransaction(rpc, simMsg);
+    if (simulation.err) {
+      if (!options?.hideFailureInfo) {
+        console.error(`Simulation failed for split bin ${binIndex}:`, simulation.err);
+        logProgramLogsLineByLine(simulation.logs, `split bin ${binIndex} simulation logs`);
+      }
+      const errStr = JSON.stringify(
+        simulation.err,
+        (_, v) => typeof v === "bigint" ? v.toString() : v
+      );
+      throw new TransactionError(
+        `Split bin ${binIndex} simulation failed: ${errStr}`,
+        simulation.logs
+      );
+    }
+    const { wireB64, signature } = await signSplitBin(
+      rpc,
+      payer,
+      bin,
+      lookupTables,
+      options?.additionalSigners,
+      blockhash,
+      priorityFeeMicroLamports
+    );
+    await rpc.sendTransaction(wireB64, {
+      encoding: "base64",
+      skipPreflight: true
+    }).send();
+    try {
+      await confirmTransaction(rpc, signature, "confirmed");
+    } catch (error) {
+      const logs = await fetchTransactionLogsWithRetry(rpc, signature);
+      if (!options?.hideFailureInfo) {
+        console.error(`Transaction failed for split bin ${binIndex}:`, signature, error);
+        logProgramLogsLineByLine(logs, `split bin ${binIndex} transaction logs`);
+      }
+      throw new TransactionError(`Transaction failed: ${error}`, logs);
+    }
+    lastSignature = signature;
+  }
+  options?.onSuccess?.();
+  return lastSignature;
+}
+async function fetchTransactionLogsWithRetry(rpc, signature) {
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    try {
+      const info = await rpc.getTransaction(signature, { commitment: "confirmed", encoding: "base64" }).send();
+      const logs = info?.meta?.logMessages ?? [];
+      if (logs.length > 0) return logs;
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  return [];
+}
+async function confirmTransaction(rpc, signature, commitment, timeoutMs = 6e4) {
+  const startTime = Date.now();
+  const pollIntervalMs = 500;
+  while (Date.now() - startTime < timeoutMs) {
+    let status = null;
+    try {
+      const response = await rpc.getSignatureStatuses([signature]).send();
+      status = response.value[0];
+    } catch (err) {
+      if (!isTransientNetworkError(err)) throw err;
+    }
+    if (status !== null) {
+      if (status.err) {
+        const errStr = JSON.stringify(
+          status.err,
+          (_, v) => typeof v === "bigint" ? v.toString() : v
+        );
+        throw new Error(`Transaction failed: ${errStr}`);
+      }
+      const confirmationStatus = status.confirmationStatus;
+      if (confirmationStatus === commitment || commitment === "processed" && confirmationStatus || commitment === "confirmed" && (confirmationStatus === "confirmed" || confirmationStatus === "finalized") || commitment === "finalized" && confirmationStatus === "finalized") {
+        return;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error(`Transaction confirmation timeout after ${timeoutMs}ms`);
+}
+
+// ../../shared/common/src/services/baseIxBuilderService.ts
+var BaseIXBuilderService = class {
+  constructor(context) {
+    this.context = context;
+  }
+};
+
+// ../../shared/common/src/services/swap/swapRouting.ts
+function swapClientCanRoute(client, inputMint, outputMint) {
+  if (inputMint === outputMint) {
+    return false;
+  }
+  if (client.inputMints.length === 0 && client.outputMints.length === 0) {
+    return true;
+  }
+  if (!client.inputMints.includes(inputMint) || !client.outputMints.includes(outputMint)) {
+    return false;
+  }
+  if (client.routeAnchorMints.length === 0) {
+    return true;
+  }
+  return client.routeAnchorMints.some((m) => m === inputMint || m === outputMint);
+}
+
+// ../../shared/oracle-service/src/constants/pyth.ts
+import { address as address5 } from "@solana/kit";
+var PYTH_FEEDS = {
+  // Standard assets
+  SOL: {
+    account: address5("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE"),
+    feedId: "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d"
+  },
+  WETH: {
+    account: address5("42amVS4KgzR9rA28tkVYqVXjq9Qa8dcZQMbH5EYFX6XC"),
+    feedId: "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace"
+  },
+  WBTC: {
+    account: address5("9gNX5vguzarZZPjTnE1hWze3s6UsZ7dsU3UnAmKPnMHG"),
+    feedId: "c9d8b075a5c69303365ae23633d4e085199bf5c520a3b90fed1322a0342ffc33"
+  },
+  CBBTC: {
+    account: address5("4cSM2e6rvbGQUFiJbqytoVMi5GgghSMr8LwVrT9VPSPo"),
+    feedId: "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43"
+  },
+  JLP: {
+    account: address5("2TTGSRSezqFzeLUH8JwRUbtN66XLLaymfYsWRTMjfiMw"),
+    feedId: "c811abc82b4bad1f9bd711a2773ccaa935b03ecef974236942cec5e0eb845a3a"
+  },
+  SPYx: {
+    account: address5("9owhtgrdLiUMAH9JKxYFt5pUY4Luy4EzzLhdcWPVuDyy"),
+    feedId: "19e09bb805456ada3979a7d1cbb4b6d63babc3a0f8e8a9509f68afa5c4c11cd5"
+  },
+  QQQx: {
+    account: address5("EwssJrQ7UVz6itHEaQQsKWikhZ3iHddyxRhmR7pTvwt5"),
+    feedId: "9695e2b96ea7b3859da9ed25b7a46a920a776e2fdae19a7bcfdf2b219230452d"
+  },
+  // LSTs
+  JupSOL: {
+    account: address5("D7UqeBmCEmhGXGYfi2y9RfoCa7t1Xw5iZLBeYZ3sxFSe"),
+    feedId: "f8d8d6b6c866c8b2624fb5b679ae846738725e5fc887fa8e927c8d8645018a2b"
+  },
+  // Stablecoins
+  USDC: {
+    account: address5("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX"),
+    feedId: "eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a"
+  },
+  USDT: {
+    account: address5("HT2PLQBcG5EiCcNSaMHAjSgd9F98ecpATbk4Sk5oYuM"),
+    feedId: "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b"
+  },
+  CASH: {
+    account: address5("F23Xi7VQw1pdre26VmuKnjRcDcrhpqGtHkGdKdSdbM8w"),
+    feedId: "df3320ef0f4617337b8dbb924f2aaa4f9db08f522a5435b44f9066c1ac4c7f95"
+  },
+  PYUSD: {
+    account: address5("9zXQxpYH3kYhtoybmZfUNNCRVuud7fY9jswTg1hLyT8k"),
+    feedId: "0xc1da1b73d7f01e7ddd54b3766cf7fcd644395ad14f70aa706ec5384c59e76692"
+  },
+  USDG: {
+    account: address5("6JkZmXGgWnzsyTQaqRARzP64iFYnpMNT4siiuUDUaB8s"),
+    feedId: "0xdaa58c6a3ce7d4b9c46c32a6e646012c17c4a2b24c08dd8c5e476118b855a7da"
+  },
+  USDS: {
+    account: address5("DyYBBWEi9xZvgNAeMDCiFnmC1U9gqgVsJDXkL5WETpoX"),
+    feedId: "0x77f0971af11cc8bac224917275c1bf55f2319ed5c654a1ca955c82fa2d297ea1"
+  },
+  // Yield bearing assets
+  PST: {
+    account: address5("CBGwQddTeYn3KdvxGWtU95fqCcavzHK9XPFBLENDF5JR"),
+    feedId: "675e36f84a6be779ed793c71eb5c03151e1866c125767f46933626e0610af84d"
+  }
+};
+
+// ../../shared/perena-helpers/src/constants.ts
+import { address as address6 } from "@solana/kit";
+var PERENA_PROGRAM_ID = address6("save8RQVPMWNTzU18t3GBvBkN9hT7jsGjiCQ28FpD9H");
+
+// ../../shared/perena-helpers/src/client.ts
+import { BN as BN3 } from "@anchor-lang/core";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import {
+  UsdStarClient,
+  BankinecoAction
+} from "@perena/bankineco-sdk";
+import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
+import { SYSTEM_PROGRAM_ADDRESS as SYSTEM_PROGRAM_ADDRESS3 } from "@solana-program/system";
+
+// ../../shared/perena-helpers/src/cpi/mint.ts
+function getPerenaMintArgs(data) {
+  const buf = Buffer.alloc(16);
+  buf.writeBigUInt64LE(BigInt(data.amountYieldingDeposit.toString()), 0);
+  buf.writeBigUInt64LE(BigInt(data.minBankMintMinted.toString()), 8);
+  return buf;
+}
+
+// ../../shared/perena-helpers/src/cpi/burn.ts
+function getPerenaBurnArgs(data) {
+  const buf = Buffer.alloc(16);
+  buf.writeBigUInt64LE(BigInt(data.amountToBurn.toString()), 0);
+  buf.writeBigUInt64LE(BigInt(data.minimumYieldingWithdrawn.toString()), 8);
+  return buf;
+}
+
+// ../../shared/perena-helpers/src/cpi/requestUnstake.ts
+function getPerenaRequestUnstakeArgs(data) {
+  const sharesBytes = numToU64Bytes(data.shares);
+  const buf = Buffer.alloc(9);
+  Buffer.from(sharesBytes).copy(buf, 0);
+  buf.writeUInt8(data.queueId, 8);
+  return buf;
+}
+
+// ../../shared/perena-helpers/src/client.ts
+var ACTIVE_WITHDRAWAL_QUEUES_CACHE_CATEGORY = "activeWithdrawalQueues";
+var PerenaClient = class {
+  /**
+   * Creates a new Perena client.
+   *
+   * @param rpcUrl - Solana RPC URL
+   */
+  constructor(rpcUrl) {
+    this.sdkClient = UsdStarClient.new({
+      env: "prod",
+      rpcUrl
+    });
+    this.cache = new DataCache({
+      defaultTtlMs: 6e4 * 5
+      // 5 minute default
+    });
+    const usdStar = mints.get("USD*");
+    if (!usdStar) {
+      throw new Error("USD* mint not found in registry");
+    }
+    this.bankMint = usdStar.address;
+    const usdStarJ = mints.get("USD*-J");
+    if (!usdStarJ) {
+      throw new Error("USD*-J mint not found in registry");
+    }
+    this.juniorMint = usdStarJ.address;
+    const yieldingMints = Object.keys(this.sdkClient.idleVaultIndices);
+    const routable = Object.freeze([this.bankMint, this.juniorMint, ...yieldingMints]);
+    this.inputMints = routable;
+    this.outputMints = routable;
+    this.routeAnchorMints = Object.freeze([this.bankMint, this.juniorMint]);
+  }
+  /**
+   * Get mints that can directly mint USD*.
+   */
+  async getSupportedSourceMints() {
+    return Object.keys(this.sdkClient.idleVaultIndices).map((key) => key);
+  }
+  /**
+   * Get current protocol info for a source mint.
+   * @param sourceMint - The source mint to get info for (i.e. USDC, USDT, etc.)
+   * @returns Protocol info including fees and limits
+   * @throws Error if sourceMint is not supported by Perena
+   */
+  async getProtocolInfo(sourceMint) {
+    const supportedSourceMints = await this.getSupportedSourceMints();
+    if (!supportedSourceMints.includes(sourceMint)) {
+      throw new Error(`Source mint ${sourceMint} is not supported by Perena`);
+    }
+    const { data } = await this.cache.getDataOrThrow(
+      async () => {
+        const vault = this.sdkClient.getVault(new PublicKey3(sourceMint));
+        const vaultInfo = await this.sdkClient.bankineco.pg.account.vaultGenState.fetch(vault);
+        return {
+          sourceMint,
+          mintFeeBps: vaultInfo.config.mintingFeeBps,
+          redemptionFeeBps: vaultInfo.config.burningFeeBps,
+          depositLimit: BigInt(0),
+          redemptionLimit: BigInt(vaultInfo.accounting.yieldingReserveAmount.toString())
+        };
+      },
+      "yieldProtocolInfo",
+      sourceMint
+    );
+    return data;
+  }
+  /**
+   * Get the latest USD* price in UI units (e.g. dollars).
+   *
+   * @returns The current bank mint price as a number
+   */
+  async getLatestBankMintUiPrice() {
+    const { data } = await this.cache.getDataOrThrow(
+      () => this.sdkClient.latestBankMintUiPrice(),
+      "bankMintUiPrice",
+      "latest"
+    );
+    return data;
+  }
+  /**
+   * Get the latest USD*-J price in UI units (e.g. dollars).
+   *
+   * @returns The current junior mint price as a number
+   */
+  async getLatestJuniorMintUiPrice() {
+    const { data } = await this.cache.getDataOrThrow(
+      () => this.sdkClient.latestJuniorMintUiPrice(),
+      "juniorMintUiPrice",
+      "latest"
+    );
+    return data;
+  }
+  /**
+   * Size a USD* burn so the routed yielding output (e.g. USDC) is at least
+   * `minYieldingOut` base units, without scanning inputs.
+   *
+   * Perena's `bankMintToYieldingQuote` is linear in the burn amount for fixed
+   * oracles: bank-mint price, yielding price, burn fee bps, and decimal
+   * rescales are all proportional in `amountToBurn`. We take **one** reference
+   * quote at exactly 1.0 bank-mint token (10^decimals base units) to read the
+   * effective `yieldingOut / bankMintIn` rate implied by the current prices,
+   * then `ceil(need * refIn / refOut)` and re-quote once at that input so the
+   * returned {@link PerenaSwapQuote} matches the CPI.
+   */
+  /**
+   * @deprecated Prefer {@link getQuoteCoveringMinOutput} — same behavior with generic param names.
+   */
+  async getQuoteCoveringYieldingOut(params) {
+    return this.getQuoteCoveringMinOutput({
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      minOutputAmount: params.minYieldingOut,
+      maxInputAmount: params.maxBankMintIn,
+      slippageBps: params.slippageBps
+    });
+  }
+  async getQuoteCoveringMinOutput(params) {
+    if (params.inputMint !== this.bankMint) {
+      throw new Error("getQuoteCoveringMinOutput only supports burning USD* into a yielding mint");
+    }
+    const need = params.minOutputAmount;
+    if (need <= BigInt(0)) {
+      throw new Error("getQuoteCoveringMinOutput: minOutputAmount must be positive");
+    }
+    const maxIn = params.maxInputAmount;
+    if (maxIn <= BigInt(0)) {
+      throw new Error("getQuoteCoveringMinOutput: maxInputAmount must be positive");
+    }
+    const vault = this.sdkClient.getVault(new PublicKey3(params.outputMint));
+    const refInBn = mints.get("USD*").fromUiAmount(1);
+    const oneBankMint = BigInt(refInBn.toString());
+    const refSdk = await this.sdkClient.bankMintToYieldingQuote(refInBn, vault);
+    const refOut = BigInt(refSdk.amount.toString());
+    if (refOut === BigInt(0)) {
+      throw new Error("Perena reference burn quote returned zero yielding output");
+    }
+    const maxSdk = await this.sdkClient.bankMintToYieldingQuote(new BN3(maxIn.toString()), vault);
+    if (BigInt(maxSdk.amount.toString()) < need) {
+      throw new Error(
+        "Perena: bank mint holding cannot cover the yielding output required for this unwind"
+      );
+    }
+    const scaleInput = (targetOut) => {
+      const numer = targetOut * oneBankMint + refOut - BigInt(1);
+      return numer / refOut;
+    };
+    let inputRaw = scaleInput(need);
+    if (inputRaw > maxIn) {
+      inputRaw = maxIn;
+    }
+    if (inputRaw < BigInt(1)) {
+      inputRaw = BigInt(1);
+    }
+    const slippageBps = params.slippageBps ?? 100;
+    const quoteAt = async (inAmt) => {
+      if (inAmt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("getQuoteCoveringMinOutput: burn input exceeds Number.MAX_SAFE_INTEGER");
+      }
+      return this.getQuote({
+        inputMint: params.inputMint,
+        outputMint: params.outputMint,
+        amount: Number(inAmt),
+        slippageBps
+      });
+    };
+    let quote = await quoteAt(inputRaw);
+    let out = BigInt(quote.outputAmount.toString());
+    if (out < need && inputRaw < maxIn) {
+      inputRaw = (need * inputRaw + out - BigInt(1)) / out;
+      if (inputRaw > maxIn) {
+        inputRaw = maxIn;
+      }
+      quote = await quoteAt(inputRaw);
+      out = BigInt(quote.outputAmount.toString());
+    }
+    if (out < need && inputRaw < maxIn) {
+      inputRaw += BigInt(1);
+      if (inputRaw > maxIn) {
+        inputRaw = maxIn;
+      }
+      quote = await quoteAt(inputRaw);
+      out = BigInt(quote.outputAmount.toString());
+    }
+    if (out < need) {
+      throw new Error(
+        "Perena: sized burn quote still below required yielding output (rounding); try larger holding or refresh oracles"
+      );
+    }
+    return quote;
+  }
+  /**
+   * Get a quote for minting/burning USD* or staking/unstaking USD*-J.
+   *
+   * The operation is determined by the mints:
+   * - outputMint is USD*: mint (yielding → USD*)
+   * - inputMint is USD*: burn (USD* → yielding)
+   * - outputMint is USD*-J: stake (USD* → USD*-J)
+   * - inputMint is USD*-J: unstake (USD*-J → USD* or yielding)
+   *
+   * @param params - Quote parameters
+   * @returns Normalized swap quote
+   * @throws Error if the mint pair is not supported
+   */
+  async getQuote(params) {
+    const isJuniorInput = params.inputMint === this.juniorMint;
+    const isJuniorOutput = params.outputMint === this.juniorMint;
+    if (isJuniorOutput) {
+      if (params.inputMint !== this.bankMint) {
+        throw new Error("Invalid Perena quote: can only stake USD* into USD*-J");
+      }
+      return this.getStakeQuote(params);
+    }
+    if (isJuniorInput) {
+      return this.getUnstakeQuote(params);
+    }
+    const isMint = params.outputMint === this.bankMint;
+    const isBurn = params.inputMint === this.bankMint;
+    if (!isMint && !isBurn) {
+      throw new Error(
+        "Invalid Perena quote: either inputMint or outputMint must be USD* or USD*-J"
+      );
+    }
+    if (isMint && isBurn) {
+      throw new Error("Invalid Perena quote: cannot swap USD* to USD*");
+    }
+    const yieldingMint = isMint ? params.inputMint : params.outputMint;
+    const yieldingMintPubkey = new PublicKey3(yieldingMint);
+    const vault = this.sdkClient.getVault(yieldingMintPubkey);
+    const amount = new BN3(params.amount);
+    const vaultInfo = await this.sdkClient.bankineco.pg.account.vaultGenState.fetch(vault);
+    const feeBps = isMint ? vaultInfo.config.mintingFeeBps : vaultInfo.config.burningFeeBps;
+    const priceImpactPct = feeBps / 100;
+    if (isMint) {
+      const sdkQuote = await this.sdkClient.yieldingToBankMintQuote(amount, vault);
+      return {
+        inputMint: params.inputMint,
+        outputMint: params.outputMint,
+        inputAmount: BigInt(params.amount),
+        outputAmount: BigInt(sdkQuote.amount.toString()),
+        priceImpactPct,
+        rawQuote: { operation: "mint", yieldingMint, sdkQuote }
+      };
+    } else {
+      const sdkQuote = await this.sdkClient.bankMintToYieldingQuote(amount, vault);
+      return {
+        inputMint: params.inputMint,
+        outputMint: params.outputMint,
+        inputAmount: BigInt(params.amount),
+        outputAmount: BigInt(sdkQuote.amount.toString()),
+        priceImpactPct,
+        rawQuote: { operation: "burn", yieldingMint, sdkQuote }
+      };
+    }
+  }
+  /**
+   * Quote for staking USD* → USD*-J.
+   *
+   * Shares minted = amount × bankMintPrice / sharePrice.
+   * Staking has no fee; the on-chain conversion is deterministic.
+   */
+  async getStakeQuote(params) {
+    const trancheState = await this.sdkClient.fetchTrancheState(true);
+    const bankState = await this.sdkClient.bankineco.pg.account.bankState.fetch(
+      this.sdkClient.bank
+    );
+    const amount = new BN3(params.amount);
+    const sharesOut = amount.mul(bankState.mint.price).div(trancheState.accounting.sharePrice);
+    return {
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      inputAmount: BigInt(params.amount),
+      outputAmount: BigInt(sharesOut.toString()),
+      priceImpactPct: 0,
+      rawQuote: { operation: "stake" }
+    };
+  }
+  /**
+   * Quote for unstaking USD*-J → USD* or yielding mint.
+   *
+   * Uses `fetchUnstakeFee` with `early: true` because instant unstake
+   * always applies the early fee.
+   */
+  async getUnstakeQuote(params) {
+    const isToYielding = params.outputMint !== this.bankMint;
+    const targetMintPk = isToYielding ? new PublicKey3(params.outputMint) : void 0;
+    const unstakeFee = await this.sdkClient.fetchUnstakeFee({
+      amount: new BN3(params.amount),
+      early: true,
+      targetMint: targetMintPk
+    });
+    const totalFee = unstakeFee.feeAmount.add(unstakeFee.burningFeeAmount);
+    const grossOutput = unstakeFee.amountAfterFee.add(totalFee);
+    const feePct = grossOutput.isZero() ? 0 : totalFee.toNumber() / grossOutput.toNumber() * 100;
+    return {
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      inputAmount: BigInt(params.amount),
+      outputAmount: BigInt(unstakeFee.amountAfterFee.toString()),
+      priceImpactPct: feePct,
+      rawQuote: {
+        operation: "unstake",
+        targetMint: isToYielding ? params.outputMint : void 0,
+        unstakeFee
+      }
+    };
+  }
+  /**
+   * Get CPI accounts for a Perena instruction.
+   *
+   * Account order matches the IDL for the respective instruction.
+   *
+   * @param quote - Quote from getQuote()
+   * @param userPublicKey - Address that will execute the swap (can be a PDA)
+   * @param options - Options on building the CPI
+   * @returns CPI accounts, program ID, and serialized instruction data
+   */
+  async getSwapCpiData(quote, userPublicKey, _options) {
+    const { operation } = quote.rawQuote;
+    switch (operation) {
+      case "mint":
+      case "burn":
+        return this.getMintBurnCpiData(quote, userPublicKey);
+      case "stake":
+        return await this.getStakeCpiData(quote, userPublicKey);
+      case "unstake":
+        return await this.getInstantUnstakeCpiData(quote, userPublicKey);
+      case "request_unstake": {
+        const rq = quote.rawQuote;
+        return await this.getRequestUnstakeCpiData({
+          shares: new BN3(quote.inputAmount.toString()),
+          queueId: rq.queueId,
+          userPublicKey,
+          payer: rq.payer,
+          targetMint: rq.targetMint
+        });
+      }
+      case "fulfill_unstake": {
+        const fq = quote.rawQuote;
+        return await this.getFulfillUnstakeCpiData({
+          withdrawalQueue: fq.withdrawalQueue,
+          signer: fq.owner,
+          queuePayer: fq.queuePayer,
+          owner: fq.owner,
+          targetMint: fq.targetMint
+        });
+      }
+    }
+  }
+  /**
+   * Derive the withdrawal queue PDA for a given user and queue slot.
+   */
+  deriveWithdrawalQueue(user, queueId) {
+    return fromWeb3Pk(
+      this.sdkClient.bankineco.withdrawalQueuePDA(this.sdkClient.bank, new PublicKey3(user), queueId)
+    );
+  }
+  /**
+   * Fetch all active withdrawal queue PDAs owned by `user`.
+   *
+   * "Active" means the queue account exists, is owned by Perena, and currently
+   * holds a non-zero locked amount.
+   */
+  async getActiveWithdrawalQueues(user) {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => {
+        const userPublicKey = new PublicKey3(user);
+        const queueInfos = await this.sdkClient.fetchAllWithdrawalQueues(userPublicKey);
+        return queueInfos.filter((queueInfo) => queueInfo.amount.gt(new BN3(0))).map((queueInfo) => fromWeb3Pk(queueInfo.address));
+      },
+      ACTIVE_WITHDRAWAL_QUEUES_CACHE_CATEGORY,
+      user
+    );
+    return data;
+  }
+  /**
+   * Cache invalidation descriptor for the active-withdrawal-queues snapshot of
+   * one owner. Use this when a transaction may create, consume, or otherwise
+   * mutate Perena withdrawal queues outside this exact client instance.
+   */
+  getActiveWithdrawalQueuesCacheInvalidation(owner) {
+    return this.getActiveWithdrawalQueuesInvalidation(owner);
+  }
+  getActiveWithdrawalQueuesInvalidation(owner) {
+    return {
+      client: "perena",
+      dataCache: this.cache,
+      category: ACTIVE_WITHDRAWAL_QUEUES_CACHE_CATEGORY,
+      id: owner
+    };
+  }
+  /**
+   * Build CPI data for mint_w_yielding_gen or burn_for_yielding_gen.
+   */
+  async getMintBurnCpiData(quote, userPublicKey) {
+    const raw = quote.rawQuote;
+    const isMint = raw.operation === "mint";
+    const action = isMint ? BankinecoAction.Mint : BankinecoAction.Burn;
+    const cpiAccounts = await this.sdkClient.getMintAndBurnCpiAccounts(
+      new PublicKey3(raw.yieldingMint),
+      action,
+      new PublicKey3(userPublicKey)
+    );
+    const accounts = [
+      toCustomAccountMeta(userPublicKey, false, void 0, false),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.bankState),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.vaultState),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.oracleState),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.yieldingMint),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.bankMint),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.yieldingUserTa),
+      {
+        ...toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.bankMintUserTa),
+        isRequiredAta: {
+          mint: fromWeb3Pk(cpiAccounts.bankMint.pubkey),
+          owner: userPublicKey,
+          tokenProgram: mints.get("USD*").tokenProgram
+        }
+      },
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.yieldingVaultAta),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.teamState),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.feeTeamAta),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.systemProgram),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.tokenProgram),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.yieldingMintProgram),
+      toCustomAccountMetaFromWeb3AccountMeta(cpiAccounts.associatedTokenProgram),
+      ...(cpiAccounts.remainingAccounts ?? []).map(
+        (meta) => toCustomAccountMeta(
+          meta.pubkey.toBase58(),
+          meta.isWritable,
+          void 0,
+          meta.isSigner
+        )
+      )
+    ];
+    return {
+      cpiType: isMint ? CpiTypes.PERENA_MINT : CpiTypes.PERENA_BURN,
+      accounts,
+      programId: PERENA_PROGRAM_ID,
+      data: isMint ? getPerenaMintArgs({
+        amountYieldingDeposit: quote.inputAmount,
+        minBankMintMinted: quote.outputAmount
+      }) : getPerenaBurnArgs({
+        amountToBurn: quote.inputAmount,
+        minimumYieldingWithdrawn: quote.outputAmount
+      })
+    };
+  }
+  /**
+   * Build CPI data for stake_junior.
+   *
+   * Account order matches the IDL:
+   *   user, tranche_state, bank_state, bank_mint, junior_mint,
+   *   user_bank_mint_ata, user_junior_mint_ata, junior_escrow_ata,
+   *   system_program, token_program, associated_token_program
+   */
+  async getStakeCpiData(quote, userPublicKey) {
+    const userPk = new PublicKey3(userPublicKey);
+    const trancheAccounts = await this.sdkClient.getStakeCpiAccounts(userPk);
+    const { bankMint, juniorMint, tokenProgram } = trancheAccounts;
+    const userBankMintAta = await getAtaAddress(
+      fromWeb3Pk(bankMint),
+      userPublicKey,
+      fromWeb3Pk(tokenProgram)
+    );
+    const userJuniorMintAta = await getAtaAddress(
+      fromWeb3Pk(juniorMint),
+      userPublicKey,
+      fromWeb3Pk(tokenProgram)
+    );
+    const accounts = [
+      toCustomAccountMeta(userPublicKey, true, void 0, false),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.trancheState), true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.bankState)),
+      toCustomAccountMeta(fromWeb3Pk(bankMint)),
+      toCustomAccountMeta(fromWeb3Pk(juniorMint), true),
+      toCustomAccountMeta(userBankMintAta, true),
+      {
+        ...toCustomAccountMeta(userJuniorMintAta, true),
+        isRequiredAta: {
+          mint: this.juniorMint,
+          owner: userPublicKey,
+          tokenProgram: mints.get("USD*-J").tokenProgram
+        }
+      },
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.juniorEscrowAta), true),
+      toCustomAccountMeta(SYSTEM_PROGRAM_ADDRESS3),
+      toCustomAccountMeta(fromWeb3Pk(tokenProgram)),
+      toCustomAccountMeta(ASSOCIATED_TOKEN_PROGRAM_ADDRESS2)
+    ];
+    return {
+      cpiType: CpiTypes.PERENA_STAKE,
+      accounts,
+      programId: PERENA_PROGRAM_ID,
+      data: numToU64Bytes(quote.inputAmount)
+    };
+  }
+  /**
+   * Build CPI data for instant_unstake_junior.
+   *
+   * Account order matches the IDL:
+   *   user, tranche_state, bank_state, bank_mint, target_mint, junior_mint,
+   *   user_junior_mint_ata, owner_bank_mint_ata, junior_escrow_ata,
+   *   locked_junior_shares_ata, token_program,
+   *   [vault_state, vault_oracle_state, vault_team_state, yielding_mint,
+   *    yielding_vault_ata, owner_yielding_ta, vault_fee_team_ata,
+   *    yielding_mint_program]  (optional, when unstaking to a yielding mint)
+   */
+  async getInstantUnstakeCpiData(quote, userPublicKey) {
+    const raw = quote.rawQuote;
+    const userPk = new PublicKey3(userPublicKey);
+    const targetMintPk = raw.targetMint ? new PublicKey3(raw.targetMint) : void 0;
+    const trancheAccounts = await this.sdkClient.getUnstakeCpiAccounts(userPk, targetMintPk);
+    const { bankMint, juniorMint, tokenProgram } = trancheAccounts;
+    const userJuniorMintAta = await getAtaAddress(
+      fromWeb3Pk(juniorMint),
+      userPublicKey,
+      fromWeb3Pk(tokenProgram)
+    );
+    const ownerBankMintAta = await getAtaAddress(
+      fromWeb3Pk(bankMint),
+      userPublicKey,
+      fromWeb3Pk(tokenProgram)
+    );
+    const targetMintAddress = raw.targetMint ?? this.bankMint;
+    const accounts = [
+      toCustomAccountMeta(userPublicKey, false, void 0, false),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.trancheState), true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.bankState), true),
+      toCustomAccountMeta(fromWeb3Pk(bankMint), true),
+      toCustomAccountMeta(targetMintAddress),
+      toCustomAccountMeta(fromWeb3Pk(juniorMint), true),
+      toCustomAccountMeta(userJuniorMintAta, true),
+      {
+        ...toCustomAccountMeta(ownerBankMintAta, true),
+        isRequiredAta: {
+          mint: fromWeb3Pk(bankMint),
+          owner: userPublicKey,
+          tokenProgram: mints.get("USD*").tokenProgram
+        }
+      },
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.juniorEscrowAta), true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.lockedJuniorSharesAta), true),
+      toCustomAccountMeta(fromWeb3Pk(tokenProgram))
+    ];
+    this.pushYieldingRedemptionAccounts(accounts, trancheAccounts, userPublicKey);
+    return {
+      cpiType: CpiTypes.PERENA_INSTANT_UNSTAKE,
+      accounts,
+      programId: PERENA_PROGRAM_ID,
+      data: numToU64Bytes(quote.inputAmount)
+    };
+  }
+  /**
+   * Build CPI data for request_unstake_junior.
+   *
+   * Account order matches the IDL:
+   *   user, payer, withdrawal_queue, tranche_state, bank_state, bank_mint,
+   *   target_mint, junior_mint, user_junior_mint_ata, locked_junior_shares_ata,
+   *   system_program, token_program
+   */
+  async getRequestUnstakeCpiData(params) {
+    const userPk = new PublicKey3(params.userPublicKey);
+    const targetMintPk = params.targetMint ? new PublicKey3(params.targetMint) : void 0;
+    const trancheAccounts = await this.sdkClient.getUnstakeCpiAccounts(userPk, targetMintPk);
+    const { bankMint, juniorMint, tokenProgram } = trancheAccounts;
+    const userJuniorMintAta = await getAtaAddress(
+      fromWeb3Pk(juniorMint),
+      params.userPublicKey,
+      fromWeb3Pk(tokenProgram)
+    );
+    const targetMintAddress = params.targetMint ?? this.bankMint;
+    const withdrawalQueue = this.deriveWithdrawalQueue(params.userPublicKey, params.queueId);
+    const accounts = [
+      toCustomAccountMeta(params.userPublicKey, false, void 0, false),
+      toCustomAccountMeta(params.payer, true, void 0, true),
+      toCustomAccountMeta(withdrawalQueue, true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.trancheState)),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.bankState)),
+      toCustomAccountMeta(fromWeb3Pk(bankMint)),
+      toCustomAccountMeta(targetMintAddress),
+      toCustomAccountMeta(fromWeb3Pk(juniorMint)),
+      toCustomAccountMeta(userJuniorMintAta, true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.lockedJuniorSharesAta), true),
+      toCustomAccountMeta(SYSTEM_PROGRAM_ADDRESS3),
+      toCustomAccountMeta(fromWeb3Pk(tokenProgram))
+    ];
+    return {
+      cpiType: CpiTypes.PERENA_REQUEST_UNSTAKE,
+      accounts,
+      programId: PERENA_PROGRAM_ID,
+      data: getPerenaRequestUnstakeArgs({
+        shares: params.shares,
+        queueId: params.queueId
+      }),
+      postSuccessCacheInvalidations: [
+        this.getActiveWithdrawalQueuesInvalidation(params.userPublicKey)
+      ]
+    };
+  }
+  /**
+   * Build CPI data for fulfill_unstake_junior.
+   *
+   * Account order matches the IDL:
+   *   signer, queue_payer, withdrawal_queue, tranche_state, bank_state,
+   *   bank_mint, junior_mint, owner_bank_mint_ata, junior_escrow_ata,
+   *   locked_junior_shares_ata, token_program,
+   *   [vault_state, vault_oracle_state, vault_team_state, yielding_mint,
+   *    yielding_vault_ata, owner_yielding_ta, vault_fee_team_ata,
+   *    yielding_mint_program]  (optional, when fulfilling to a yielding mint)
+   */
+  async getFulfillUnstakeCpiData(params) {
+    const ownerPk = new PublicKey3(params.owner);
+    const targetMintPk = params.targetMint ? new PublicKey3(params.targetMint) : void 0;
+    const trancheAccounts = await this.sdkClient.getUnstakeCpiAccounts(ownerPk, targetMintPk);
+    const { bankMint, juniorMint, tokenProgram } = trancheAccounts;
+    const ownerBankMintAta = await getAtaAddress(
+      fromWeb3Pk(bankMint),
+      params.owner,
+      fromWeb3Pk(tokenProgram)
+    );
+    const accounts = [
+      toCustomAccountMeta(params.signer, false, void 0, false),
+      toCustomAccountMeta(params.queuePayer, true),
+      toCustomAccountMeta(params.withdrawalQueue, true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.trancheState), true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.bankState), true),
+      toCustomAccountMeta(fromWeb3Pk(bankMint), true),
+      toCustomAccountMeta(fromWeb3Pk(juniorMint), true),
+      {
+        ...toCustomAccountMeta(ownerBankMintAta, true),
+        isRequiredAta: {
+          mint: fromWeb3Pk(bankMint),
+          owner: params.owner,
+          tokenProgram: mints.get("USD*").tokenProgram
+        }
+      },
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.juniorEscrowAta), true),
+      toCustomAccountMeta(fromWeb3Pk(trancheAccounts.lockedJuniorSharesAta), true),
+      toCustomAccountMeta(fromWeb3Pk(tokenProgram))
+    ];
+    this.pushYieldingRedemptionAccounts(accounts, trancheAccounts, params.owner);
+    return {
+      cpiType: CpiTypes.PERENA_FULFILL_UNSTAKE,
+      accounts,
+      programId: PERENA_PROGRAM_ID,
+      data: new Uint8Array(0),
+      postSuccessCacheInvalidations: [this.getActiveWithdrawalQueuesInvalidation(params.owner)]
+    };
+  }
+  /**
+   * Appends the 8 yielding-redemption account slots that `instant_unstake_junior`
+   * and `fulfill_unstake_junior` expect after `token_program`.
+   *
+   * When a yielding mint is involved, real accounts are pushed. Otherwise Anchor
+   * still requires all 8 slots to be present — each set to the program ID as the
+   * `Option<Account>` sentinel for `None`.
+   */
+  pushYieldingRedemptionAccounts(accounts, trancheAccounts, owner) {
+    const yr = trancheAccounts.yieldingRedemption;
+    if (yr) {
+      accounts.push(
+        toCustomAccountMeta(fromWeb3Pk(yr.vaultState), true),
+        toCustomAccountMeta(fromWeb3Pk(yr.vaultOracleState)),
+        toCustomAccountMeta(fromWeb3Pk(yr.vaultTeamState), true),
+        toCustomAccountMeta(fromWeb3Pk(yr.yieldingMint)),
+        toCustomAccountMeta(fromWeb3Pk(yr.yieldingVaultAta), true),
+        {
+          ...toCustomAccountMeta(fromWeb3Pk(yr.ownerYieldingTa), true),
+          isRequiredAta: {
+            mint: fromWeb3Pk(yr.yieldingMint),
+            owner,
+            tokenProgram: fromWeb3Pk(yr.yieldingMintProgram)
+          }
+        },
+        toCustomAccountMeta(fromWeb3Pk(yr.vaultFeeTeamAta), true),
+        toCustomAccountMeta(fromWeb3Pk(yr.yieldingMintProgram))
+      );
+    } else {
+      const sentinel = PERENA_PROGRAM_ID;
+      for (let i = 0; i < 8; i++) {
+        accounts.push(toCustomAccountMeta(sentinel));
+      }
+    }
+    if (trancheAccounts.remainingAccounts) {
+      for (const meta of trancheAccounts.remainingAccounts) {
+        accounts.push(
+          toCustomAccountMeta(
+            meta.pubkey.toBase58(),
+            meta.isWritable,
+            void 0,
+            meta.isSigner
+          )
+        );
+      }
+    }
+  }
+};
+
+// ../../shared/perena-helpers/src/utils.ts
+function getPerenaWithdrawalQueueAddressesFromCpiData(cpiData) {
+  return cpiData.filter(
+    (cpi) => cpi.cpiType === CpiTypes.PERENA_REQUEST_UNSTAKE || cpi.cpiType === CpiTypes.PERENA_FULFILL_UNSTAKE
+  ).map((cpi) => cpi.accounts[2]?.address).filter((address9) => address9 !== void 0);
+}
+async function getGeneralLookupTableAccountsForPerena(perenaClient) {
+  const bankMintInfo = mints.get("USD*");
+  const juniorMintInfo = mints.get("USD*-J");
+  const usdcMintInfo = mints.get("USDC");
+  if (!bankMintInfo || !juniorMintInfo || !usdcMintInfo) {
+    throw new Error("USD*, USD*-J, and USDC must exist in the mint registry");
+  }
+  const dummyUser = DEFAULT_PUBLIC_KEY;
+  const bankMintUserAta = await getAtaAddress(
+    bankMintInfo.address,
+    dummyUser,
+    bankMintInfo.tokenProgram
+  );
+  const juniorMintUserAta = await getAtaAddress(
+    juniorMintInfo.address,
+    dummyUser,
+    juniorMintInfo.tokenProgram
+  );
+  const usdcMintUserAta = await getAtaAddress(
+    usdcMintInfo.address,
+    dummyUser,
+    usdcMintInfo.tokenProgram
+  );
+  const allAccounts = [];
+  const stakeQuote = await perenaClient.getQuote({
+    inputMint: bankMintInfo.address,
+    outputMint: juniorMintInfo.address,
+    amount: wholeTokenAmount(bankMintInfo.decimals),
+    slippageBps: 50
+  });
+  const stakeCpi = await perenaClient.getSwapCpiData(stakeQuote, dummyUser);
+  allAccounts.push(
+    ...filterSpecificAccounts(
+      stakeCpi.accounts.map((account) => account.address),
+      [DEFAULT_PUBLIC_KEY, bankMintUserAta, juniorMintUserAta]
+    )
+  );
+  const mintQuote = await perenaClient.getQuote({
+    inputMint: usdcMintInfo.address,
+    outputMint: bankMintInfo.address,
+    amount: wholeTokenAmount(usdcMintInfo.decimals),
+    slippageBps: 50
+  });
+  const mintCpi = await perenaClient.getSwapCpiData(mintQuote, dummyUser);
+  allAccounts.push(
+    ...filterSpecificAccounts(
+      mintCpi.accounts.map((account) => account.address),
+      [DEFAULT_PUBLIC_KEY, usdcMintUserAta, bankMintUserAta]
+    )
+  );
+  const burnQuote = await perenaClient.getQuote({
+    inputMint: bankMintInfo.address,
+    outputMint: usdcMintInfo.address,
+    amount: wholeTokenAmount(bankMintInfo.decimals),
+    slippageBps: 50
+  });
+  const burnCpi = await perenaClient.getSwapCpiData(burnQuote, dummyUser);
+  allAccounts.push(
+    ...filterSpecificAccounts(
+      burnCpi.accounts.map((account) => account.address),
+      [DEFAULT_PUBLIC_KEY, bankMintUserAta, usdcMintUserAta]
+    )
+  );
+  return dedupeOrderedAddresses(allAccounts);
+}
+
+// ../../shared/oracle-service/src/oracle.ts
+import { address as address8 } from "@solana/kit";
+
+// ../../shared/oracle-service/src/constants/switchboard.ts
+var SWITCHBOARD_PRICE_FEED_IDS = {
+  SOL: {
+    feedId: "4Hmd6PdjVA9auCoScE12iaBogfwS4ZXQ6VZoBeqanwWW",
+    feedHash: "0x1f42dfb21efb24828b99fbe70e6d139cd665aafcbb1706bccd8f2a9b12562db6"
+  }
+};
+
+// ../../shared/oracle-service/src/feeds/jupiter.ts
+import { retry } from "ts-retry";
+
+// ../../shared/oracle-service/src/feeds/priceBase.ts
+var PriceBase = class {
+  constructor() {
+    this.dataCache = new DataCache({
+      defaultTtlMs: PRICE_STALENESS_SECONDS * 1e3
+    });
+  }
+  async fetchPrices(mints2, bypassCache, context) {
+    if (!mints2.length) {
+      return {};
+    }
+    if (bypassCache) {
+      return await this.internalFetchPrices(mints2, context);
+    }
+    const { data } = await this.dataCache.getDataBatch(
+      async () => {
+        const prices = await this.internalFetchPrices(mints2, context);
+        return mints2.map((mint) => prices[mint] ?? null);
+      },
+      "prices",
+      mints2
+    );
+    return Object.fromEntries(mints2.map((mint, i) => [mint, data[i] ?? 0]));
+  }
+};
+
+// ../../shared/oracle-service/src/feeds/jupiter.ts
+var JupiterPrices = class extends PriceBase {
+  async getJupPriceData(mints2) {
+    const batches = getBatches(mints2, 50);
+    const results = await Promise.all(
+      batches.map(
+        (batch) => retry(
+          async () => {
+            const res = await (await fetch(
+              "https://lite-api.jup.ag/price/v3?ids=" + batch.map((x) => x.toString()).join(",")
+            )).json();
+            if (!res || typeof res !== "object") {
+              throw new Error("Failed to get mint prices using Jupiter");
+            }
+            return res;
+          },
+          { maxTry: 6, delay: 250 }
+        )
+      )
+    );
+    return Object.assign({}, ...results);
+  }
+  async internalFetchPrices(mints2, _context) {
+    if (mints2.length == 0) {
+      return {};
+    }
+    const priceData = await this.getJupPriceData(mints2);
+    const sortedPrices = {};
+    for (const mint of mints2) {
+      const key = mint.toString();
+      if (priceData.hasOwnProperty(key)) {
+        sortedPrices[key] = priceData[key];
+      }
+    }
+    const prices = Object.fromEntries(
+      mints2.map((mint) => [
+        mint,
+        sortedPrices !== null && typeof sortedPrices === "object" && typeof sortedPrices[mint.toString()] === "object" && "usdPrice" in sortedPrices[mint.toString()] ? { realtimePrice: parseFloat(sortedPrices[mint.toString()].usdPrice) } : { realtimePrice: 0 }
+      ])
+    );
+    return prices;
+  }
+};
+
+// ../../shared/oracle-service/src/constants/splStake.ts
+import { address as address7 } from "@solana/kit";
+var DFDVSOL_STAKE_POOL = address7("pyZMBjpWsVjKANAYK5mpNbKiws2krjRPZ2N2UYCSnbP");
+
+// ../../shared/oracle-service/src/feeds/pyth.ts
+import { retry as retry2 } from "ts-retry";
+
+// ../../shared/oracle-service/src/feeds/splStake.ts
+var SPL_STAKE_PRICE_CAP_MULTIPLIER = 1.1;
+var STAKE_POOL_TOTAL_LAMPORTS_OFFSET = 258;
+var STAKE_POOL_POOL_TOKEN_SUPPLY_OFFSET = 266;
+function errorWithCause(message, cause) {
+  const err = new Error(message);
+  err.cause = cause;
+  return err;
+}
+function deriveValue(price, exponent) {
+  if (exponent > 0) return Number(fromUiAmount(Number(price), exponent));
+  if (exponent < 0) return toUiAmount(BigInt(price), Math.abs(exponent));
+  return Number(price);
+}
+async function fetchStakeRate(rpcUrl, stakePool) {
+  const rpc = createRpcWithRetry(rpcUrl);
+  const redactedRpcUrl = redactRpcUrlForLog(rpcUrl);
+  let response;
+  try {
+    response = await rpc.getAccountInfo(stakePool, { encoding: "base64" }).send();
+  } catch (err) {
+    throw errorWithCause(
+      `SPL stake pool getAccountInfo failed (stakePool=${stakePool}, rpc=${redactedRpcUrl})`,
+      err
+    );
+  }
+  const { value } = response;
+  if (!value) {
+    throw new Error(
+      `SPL stake pool account not found (stakePool=${stakePool}, rpc=${redactedRpcUrl})`
+    );
+  }
+  const data = Buffer.from(value.data[0], "base64");
+  const totalLamports = data.readBigUInt64LE(STAKE_POOL_TOTAL_LAMPORTS_OFFSET);
+  const poolTokenSupply = data.readBigUInt64LE(STAKE_POOL_POOL_TOKEN_SUPPLY_OFFSET);
+  if (poolTokenSupply === BigInt(0)) {
+    throw new Error(
+      `SPL stake pool has zero pool token supply (stakePool=${stakePool}, rpc=${redactedRpcUrl})`
+    );
+  }
+  return Number(totalLamports) / Number(poolTokenSupply);
+}
+async function fetchSolUsd(feedId) {
+  let resp;
+  try {
+    resp = await pythRequest([feedId]);
+  } catch (err) {
+    throw errorWithCause(`Pyth SOL/USD request failed before response (feedId=${feedId})`, err);
+  }
+  if (resp.status !== 200) {
+    const body = await resp.text().catch(() => "<failed to read response body>");
+    throw new Error(
+      `Pyth SOL/USD request failed status=${resp.status} feedId=${feedId} body=${body}`
+    );
+  }
+  let json;
+  try {
+    json = await resp.json();
+  } catch (err) {
+    throw errorWithCause(`Pyth SOL/USD response JSON parse failed (feedId=${feedId})`, err);
+  }
+  const price = json.parsed[0].price;
+  return deriveValue(price.price, price.expo);
+}
+async function getSplStakeLstUiPrice(rpcUrl, config) {
+  const [rate, solUsd] = await Promise.all([
+    fetchStakeRate(rpcUrl, config.stakePool),
+    fetchSolUsd(config.pythSolFeed.feedId)
+  ]);
+  return Math.min(rate * solUsd, SPL_STAKE_PRICE_CAP_MULTIPLIER * solUsd);
+}
+
+// ../../shared/oracle-service/src/utils/general.ts
+async function pythRequest(feedIds) {
+  return await fetchWithRetry(
+    `https://hermes.pyth.network/v2/updates/price/latest?${feedIds.map((x) => `ids%5B%5D=${x}`).join("&")}`
+  );
+}
+var perenaOracleAccounts = new PerenaClient(getMainnetRpcUrl());
+function registerUsdStarOracle(oracle2) {
+  oracle2.registerCustomOracle("USD*", {
+    priceFetcher: (rpcUrl) => new PerenaClient(rpcUrl).getLatestBankMintUiPrice(),
+    oracle: fromWeb3Pk(perenaOracleAccounts.sdkClient.bank),
+    oracleType: 2 /* PerenaBank */
+  });
+}
+function registerUsdStarJuniorOracle(oracle2) {
+  oracle2.registerCustomOracle("USD*-J", {
+    priceFetcher: (rpcUrl) => new PerenaClient(rpcUrl).getLatestJuniorMintUiPrice(),
+    oracle: fromWeb3Pk(perenaOracleAccounts.sdkClient.tranche),
+    oracleType: 3 /* PerenaTranche */
+  });
+}
+function registerSplStakeLstOracle(oracle2, config) {
+  oracle2.registerCustomOracle(config.mint, {
+    priceFetcher: (rpcUrl) => getSplStakeLstUiPrice(rpcUrl, config),
+    oracle: config.pythSolFeed.account,
+    oracleType: 4 /* PythSplStake */,
+    secondaryOracle: config.stakePool
+  });
+}
+function registerDfdvSolOracle(oracle2) {
+  const dfdvSol = mints.get("dfdvSOL");
+  registerSplStakeLstOracle(oracle2, {
+    mint: dfdvSol.address,
+    stakePool: DFDVSOL_STAKE_POOL,
+    pythSolFeed: PYTH_FEEDS.SOL
+  });
+}
+
+// ../../shared/oracle-service/src/feeds/pyth.ts
+var PythPrices = class extends PriceBase {
+  constructor() {
+    super(...arguments);
+    this.deriveValue = (price, exponent) => {
+      if (exponent > 0) {
+        return Number(fromUiAmount(Number(price), exponent));
+      } else if (exponent < 0) {
+        return toUiAmount(BigInt(price), Math.abs(exponent));
+      } else {
+        return Number(price);
+      }
+    };
+  }
+  findFeed(symbol) {
+    const key = findKeyIgnoreCase(PYTH_FEEDS, symbol);
+    return key ? PYTH_FEEDS[key] : void 0;
+  }
+  async internalFetchPrices(mints2, _context) {
+    const feedIds = mints2.map((mint) => {
+      const symbol = mints.get(mint)?.symbol;
+      const feed = symbol ? this.findFeed(symbol) : void 0;
+      if (!feed) {
+        throw new Error(`No Pyth feed configured for mint ${mint.toString()}`);
+      }
+      return feed.feedId;
+    });
+    const prices = await retry2(
+      async () => {
+        const resp = await pythRequest(feedIds);
+        const status = resp.status;
+        if (status !== 200) {
+          const body = await resp.text().catch(() => "<failed to read response body>");
+          throw new Error(
+            `Pyth price request failed status=${status} statusText=${resp.statusText} feedIds=${feedIds.join(",")} body=${body}`
+          );
+        }
+        const json = await resp.json();
+        const prices2 = json.parsed.map((x) => {
+          return {
+            realtimePrice: this.deriveValue(x.price.price, x.price.expo),
+            emaPrice: this.deriveValue(x.ema_price.price, x.ema_price.expo)
+          };
+        });
+        return prices2;
+      },
+      {
+        maxTry: 5,
+        delay: 250
+      }
+    );
+    return createRecord(
+      mints2.map((x) => x.toString()),
+      prices
+    );
+  }
+};
+
+// ../../shared/oracle-service/src/feeds/switchboard.ts
+var SwitchboardPrices = class extends PriceBase {
+  async internalFetchPrices(mints2, _context) {
+    return {};
+  }
+};
+
+// ../../shared/oracle-service/src/feeds/custom.ts
+var CustomPrices = class extends PriceBase {
+  constructor() {
+    super(...arguments);
+    this.customOracles = /* @__PURE__ */ new Map();
+  }
+  getLookupKeys(mint) {
+    const symbol = mints.get(mint)?.symbol;
+    const address9 = mints.get(mint)?.address;
+    return [mint, symbol, address9].filter((key) => key !== void 0);
+  }
+  /**
+   * Register a custom price fetcher for a given mint.
+   *
+   * @param mint - The mint identifier
+   * @param fetcher - An async function that returns the current price
+   */
+  registerCustomOracle(mint, oracle2) {
+    this.customOracles.set(mint, oracle2);
+  }
+  /**
+   * Check if a custom price fetcher is registered for a given mint.
+   */
+  hasCustomOracle(mint) {
+    return this.getLookupKeys(mint).some((key) => this.customOracles.has(key));
+  }
+  async internalFetchPrices(mints2, context) {
+    const rpcUrl = context?.rpcUrl;
+    if (!rpcUrl) {
+      throw new Error("Custom oracle price fetch requires an RPC URL");
+    }
+    const entries = await Promise.all(
+      mints2.map(async (mint) => {
+        const oracle2 = this.getCustomOracle(mint);
+        if (!oracle2) {
+          return [mint, { realtimePrice: 0 }];
+        }
+        const price = await oracle2.priceFetcher(rpcUrl);
+        return [mint, { realtimePrice: price }];
+      })
+    );
+    return Object.fromEntries(entries);
+  }
+  getCustomOracle(mint) {
+    for (const key of this.getLookupKeys(mint)) {
+      const oracle2 = this.customOracles.get(key);
+      if (oracle2) {
+        return oracle2;
+      }
+    }
+    return void 0;
+  }
+};
+
+// ../../shared/oracle-service/src/oracle.ts
+var OracleService = class {
+  constructor() {
+    this.jupiter = new JupiterPrices();
+    this.pyth = new PythPrices();
+    this.switchboard = new SwitchboardPrices();
+    this.custom = new CustomPrices();
+  }
+  /**
+   * Register a custom oracle for a given mint.
+   * Custom-registered mints take priority over all other oracle sources.
+   */
+  registerCustomOracle(mint, oracle2) {
+    this.custom.registerCustomOracle(mint, oracle2);
+  }
+  getOracleData(mint) {
+    const customOracle = this.custom.getCustomOracle(mint);
+    if (customOracle) {
+      return {
+        oracle: customOracle.oracle,
+        oracleType: customOracle.oracleType,
+        secondaryOracle: customOracle.secondaryOracle
+      };
+    }
+    const symbol = mints.get(mint)?.symbol;
+    const pythSymbol = symbol ? findKeyIgnoreCase(PYTH_FEEDS, symbol) : void 0;
+    const switchboardSymbol = symbol ? findKeyIgnoreCase(SWITCHBOARD_PRICE_FEED_IDS, symbol) : void 0;
+    return {
+      oracle: pythSymbol ? PYTH_FEEDS[pythSymbol].account : address8(SWITCHBOARD_PRICE_FEED_IDS[switchboardSymbol].feedId),
+      oracleType: pythSymbol ? 0 /* Pyth */ : 1 /* Switchboard */,
+      secondaryOracle: void 0
+    };
+  }
+  clearCache() {
+    this.jupiter.dataCache.clearAllCache();
+    this.pyth.dataCache.clearAllCache();
+    this.switchboard.dataCache.clearAllCache();
+    this.custom.dataCache.clearAllCache();
+  }
+  async fetchPrices(mints2, mode, bypassCache, environment = ENVIRONMENT) {
+    if (!mints2.length) {
+      return {};
+    }
+    const rpcUrl = getRpcUrl(environment);
+    const customMints = [];
+    const pythMints = [];
+    const switchboardMints = [];
+    const jupiterMints = [];
+    for (const mint of mints2) {
+      if (this.custom.hasCustomOracle(mint)) {
+        customMints.push(mint);
+      } else {
+        const symbol = mints.get(mint)?.symbol;
+        if (symbol && findKeyIgnoreCase(PYTH_FEEDS, symbol)) {
+          pythMints.push(mint);
+        } else if (symbol && findKeyIgnoreCase(SWITCHBOARD_PRICE_FEED_IDS, symbol)) {
+          switchboardMints.push(mint);
+        } else {
+          jupiterMints.push(mint);
+        }
+      }
+    }
+    const [customPrices, pythPrices, switchboardPrices, jupiterPrices] = await Promise.all([
+      customMints.length ? this.custom.fetchPrices(customMints, bypassCache, { rpcUrl }) : {},
+      pythMints.length ? this.pyth.fetchPrices(pythMints, bypassCache) : {},
+      switchboardMints.length ? this.switchboard.fetchPrices(switchboardMints, bypassCache) : {},
+      jupiterMints.length ? this.jupiter.fetchPrices(jupiterMints, bypassCache) : {}
+    ]);
+    const toNumber = (result) => mode === "realtime" ? result.realtimePrice : result.emaPrice ?? result.realtimePrice;
+    const prices = {};
+    for (const mint of mints2) {
+      const price = toNumber(
+        customPrices[mint] ?? pythPrices[mint] ?? switchboardPrices[mint] ?? jupiterPrices[mint]
+      );
+      const isStablecoin = mints.get(mint)?.assetType === "Stablecoin";
+      prices[mint] = isStablecoin ? Math.min(price, 1) : price;
+    }
+    return prices;
+  }
+};
+var oracle = new OracleService();
+registerUsdStarOracle(oracle);
+registerUsdStarJuniorOracle(oracle);
+registerDfdvSolOracle(oracle);
+
+export {
+  toCustomAccountMeta,
+  accountExists,
+  toWeb3Pk,
+  fromWeb3Pk,
+  toWeb3AccountMeta,
+  toKitInstruction,
+  getAtaAddress,
+  fetchSplTokenAccountAmounts,
+  DataCache,
+  BaseAccountClient,
+  applyDataCacheTransactionInvalidations,
+  createMultiCpiRefs,
+  createCpiRefs,
+  dedupeOrderedAddresses,
+  maxByNumber,
+  sleep,
+  createSignerFromAddress,
+  getSlot,
+  ENVIRONMENT,
+  DAYS_PER_YEAR,
+  TVL_USD_DECIMAL_PLACES,
+  DEFAULT_PUBLIC_KEY,
+  LOCALNET_URL,
+  PROTOCOL_ADMIN,
+  DEPLOYED_ADMIN_KEYPAIR_FP,
+  PRICE_STALENESS_SECONDS,
+  U64_MAX_BN,
+  toUiAmount,
+  fromUiAmount,
+  calculateTvlUsd,
+  tvlUsdToBaseUnits,
+  bnFromBigInt,
+  applyFeeCeil,
+  currentUnixSeconds,
+  sum,
+  toBigInt,
+  applyBps,
+  toSafeNumber,
+  numToU64Bytes,
+  mints,
+  mintSymbol,
+  requestHeapFrameIx,
+  getCreateAtaInstructions,
+  getCreateAtaIxIfNeeded,
+  getWrapSolInstructions,
+  getUnwrapSolInstruction,
+  fetchWithRetry,
+  createRpcWithRetry,
+  createRpcWithFailover,
+  createRpc,
+  getRpcUrl,
+  getRpcUrls,
+  createReadOnlyAnchorProvider,
+  RENT_SYSVAR_META,
+  SYSTEM_PROGRAM_META,
+  IX_SYSVAR_META,
+  CpiTypes,
+  lutManager,
+  JITO_TIP_ACCOUNTS,
+  TransactionError,
+  signSendAndConfirmTransaction,
+  enumToOracleType,
+  ExternalLiquidityTypeToEnum,
+  enumToExternalLiquidityType,
+  enumToTokenProgram,
+  lendingPlatformToEnum,
+  enumToLendingPlatform,
+  resolveTokenProgram,
+  createMint,
+  BaseIXBuilderService,
+  swapClientCanRoute,
+  PYTH_FEEDS,
+  PERENA_PROGRAM_ID,
+  PerenaClient,
+  getPerenaWithdrawalQueueAddressesFromCpiData,
+  getGeneralLookupTableAccountsForPerena,
+  oracle
+};
+//# sourceMappingURL=chunk-2T23QQCX.mjs.map