@1delta/margin-fetcher-sol 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -8792,260 +8792,842 @@ function createJupiterLendApi(opts = {}) {
   };
 }
 
-// src/lending/public-data/jupiter-lend/convertPublic.ts
-var JL_FACTOR_SCALE = 1e3;
-var JL_BPS = 1e4;
-var JL_ORACLE_DECIMALS = 15;
-var JL_ORACLE_SCALE = 10 ** JL_ORACLE_DECIMALS;
-var FLUID_ORACLE_DECIMALS = 27;
-var FLUID_VAULT_TYPE_T1 = 1e4;
-var bpsToPercent = (v) => num(v) / 100;
-var jlOraclePriceInBorrow = (raw2) => num(raw2) / JL_ORACLE_SCALE;
-function jlOracleToFluidRaw(raw2, colDecimals, debtDecimals) {
-  if (typeof raw2 !== "string" || !/^\d+$/.test(raw2)) return void 0;
-  const exp = FLUID_ORACLE_DECIMALS - JL_ORACLE_DECIMALS + debtDecimals - colDecimals;
-  const v = BigInt(raw2);
-  return (exp >= 0 ? v * 10n ** BigInt(exp) : v / 10n ** BigInt(-exp)).toString();
-}
-function formatRawUnits(raw2, decimals) {
-  let v;
-  try {
-    v = BigInt(raw2 ?? 0);
-  } catch {
-    return "0";
-  }
-  const neg = v < 0n;
-  if (neg) v = -v;
-  const base = 10n ** BigInt(decimals);
-  const whole = v / base;
-  const frac = (v % base).toString().padStart(decimals, "0").replace(/0+$/, "");
-  return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
-}
-function deriveLayerTotals(vaults, earn) {
-  const t = {};
-  const slot = (mint, decimals) => t[mint] ??= { supply: 0n, borrow: 0n, decimals };
-  for (const e of earn)
-    slot(e.assetAddress, e.asset.decimals).supply += BigInt(
-      e.liquiditySupplyData.supply || "0"
-    );
-  for (const v of vaults) {
-    slot(v.supplyToken.address, v.supplyToken.decimals).supply += BigInt(
-      v.liquiditySupplyData.supply || "0"
-    );
-    slot(v.borrowToken.address, v.borrowToken.decimals).borrow += BigInt(
-      v.liquidityBorrowData.borrow || "0"
-    );
-  }
-  return t;
-}
-var fmt = (raw2, decimals) => Number(raw2) / 10 ** decimals;
-var jupiterLendCurrency = (t, listed3) => {
-  const base = listed3 ?? {
-    chainId: SOLANA_CHAIN_ID,
-    address: t.address,
-    symbol: t.uiSymbol ?? t.symbol,
-    name: t.name,
-    decimals: t.decimals
-  };
-  return { ...base, assetGroup: base.assetGroup || `solana-${t.address}` };
-};
-function convertJupiterLendVault(market, v, opts = {}) {
-  const lenderKey = jupiterLendVaultKey(market, v.id);
-  const sup = v.supplyToken;
-  const bor = v.borrowToken;
-  const supPrice = num(sup.price);
-  const borPrice = num(bor.price);
-  const ltv = num(v.collateralFactor) / JL_FACTOR_SCALE;
-  const lt = num(v.liquidationThreshold) / JL_FACTOR_SCALE;
-  const penalty = num(v.liquidationPenalty) / JL_BPS;
-  const supAsset = jupiterLendCurrency(sup, opts.tokenList?.[sup.address]);
-  const borAsset = jupiterLendCurrency(bor, opts.tokenList?.[bor.address]);
-  const supSym = supAsset.symbol ?? sup.symbol;
-  const borSym = borAsset.symbol ?? bor.symbol;
-  const label = `${supSym} / ${borSym} \xB7 vault #${v.id}`;
-  const intrinsic = (a) => opts.intrinsicYields?.[a.assetGroup] ?? 0;
-  const layerOf = (mint) => {
-    const l = opts.layer?.[mint];
-    if (!l || l.supply === 0n) return { utilization: 0 };
-    return {
-      utilization: Number(l.borrow * 10000n / l.supply) / 1e4,
-      irmTotalDeposits: fmt(l.supply, l.decimals),
-      irmTotalDebt: fmt(l.borrow, l.decimals)
-    };
-  };
-  const totalSupply = BigInt(v.totalSupply || "0");
-  const withdrawLimit = BigInt(v.withdrawLimit || "0");
-  const lockupRatio = totalSupply > 0n ? Number(withdrawLimit * 10000n / totalSupply) / 1e4 : 0;
-  const supplyDeposits = fmt(v.totalSupply, sup.decimals);
-  const borrowDebt = fmt(v.totalBorrow, bor.decimals);
-  const borrowable = fmt(v.borrowable, bor.decimals);
-  const collateralConfig = {
-    category: 0,
-    label,
-    borrowCollateralFactor: ltv,
-    collateralFactor: lt,
-    borrowFactor: 1,
-    liquidationPenalty: penalty,
-    closeFactor: 1,
-    collateralDisabled: false,
-    debtDisabled: true
-  };
-  const debtConfig = {
-    category: 0,
-    label,
-    borrowCollateralFactor: 0,
-    collateralFactor: 0,
-    borrowFactor: 1,
-    liquidationPenalty: 0,
-    closeFactor: 1,
-    collateralDisabled: true,
-    debtDisabled: false
-  };
-  const common = {
-    totalDebtStable: "0",
-    totalDebtStableUSD: 0,
-    stableBorrowRate: 0,
-    hasStable: false,
-    isActive: true,
-    isFrozen: false,
-    debtCeiling: "0",
-    closeFactor: 1,
-    lockupRatio,
-    rewards: []
-  };
-  const colUid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, sup.address);
-  const debtUid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, bor.address);
-  const collateralLeg = {
-    ...common,
-    marketUid: colUid,
-    name: `Collateral ${supSym}`,
-    poolId: sup.address,
-    underlying: sup.address,
-    asset: supAsset,
-    decimals: sup.decimals,
-    totalDeposits: formatRawUnits(v.totalSupply, sup.decimals),
-    totalDebt: "0",
-    totalLiquidity: supplyDeposits,
-    borrowLiquidity: 0,
-    totalDepositsUSD: supplyDeposits * supPrice,
-    totalDebtUSD: 0,
-    totalLiquidityUSD: supplyDeposits * supPrice,
-    borrowLiquidityUSD: 0,
-    ...layerOf(sup.address),
-    depositRate: bpsToPercent(v.supplyRate),
-    variableBorrowRate: 0,
-    intrinsicYield: intrinsic(supAsset),
-    liquidationBonus: penalty,
-    config: { "0": collateralConfig },
-    collateralActive: true,
-    borrowingEnabled: false,
-    depositsEnabled: true
-  };
-  const debtLeg = {
-    ...common,
-    marketUid: debtUid,
-    name: `Loan ${borSym}`,
-    poolId: bor.address,
-    underlying: bor.address,
-    asset: borAsset,
-    decimals: bor.decimals,
-    totalDeposits: "0",
-    totalDebt: formatRawUnits(v.totalBorrow, bor.decimals),
-    totalLiquidity: borrowable,
-    borrowLiquidity: borrowable,
-    totalDepositsUSD: 0,
-    totalDebtUSD: borrowDebt * borPrice,
-    totalLiquidityUSD: borrowable * borPrice,
-    borrowLiquidityUSD: borrowable * borPrice,
-    ...layerOf(bor.address),
-    depositRate: 0,
-    variableBorrowRate: bpsToPercent(v.borrowRate),
-    intrinsicYield: intrinsic(borAsset),
-    liquidationBonus: 0,
-    originationFee: num(v.borrowFee) / 100,
-    config: { "0": debtConfig },
-    collateralActive: false,
-    borrowingEnabled: true,
-    depositsEnabled: false
-  };
-  const vault = {
-    vaultAddress: v.address,
-    vaultId: v.id,
-    collateralAddress: sup.address,
-    loanAddress: bor.address,
-    collateralDecimals: sup.decimals,
-    loanDecimals: bor.decimals,
-    oracle: v.oracle,
-    ltv,
-    liquidationThreshold: lt,
-    liquidationPenalty: penalty,
-    oraclePriceOperate: jlOracleToFluidRaw(
-      v.oraclePriceOperate,
-      sup.decimals,
-      bor.decimals
-    ),
-    oraclePriceLiquidate: jlOracleToFluidRaw(
-      v.oraclePriceLiquidate,
-      sup.decimals,
-      bor.decimals
-    ),
-    isSmartCol: false,
-    isSmartDebt: false,
-    vaultType: FLUID_VAULT_TYPE_T1,
-    collateral: {
-      assets: [{ underlying: sup.address, decimals: sup.decimals }],
-      dex: null,
-      perShare: null
+// src/lending/public-data/jupiter-lend/onchain.ts
+import {
+  decodeBase58 as decodeBase583,
+  decodeIdlAccount as decodeIdlAccount3,
+  findProgramAddress as findProgramAddress3,
+  fromBase64 as fromBase643
+} from "@1delta/svm-kit";
+
+// src/lending/public-data/jupiter-lend/idl/vaults-accounts.json
+var vaults_accounts_default = {
+  address: "jupr81YtYssSyPt8jbnGuiWon5f6x9TcDEFxYe3Bdzi",
+  metadata: {
+    name: "vaults",
+    version: "0.1.5",
+    spec: "0.1.0",
+    description: "Account layouts only, vendored from the vaults program IDL (pos-indexer apps/sol-indexer/src/events/idl/jupiter-lend/vaults.json, v0.1.5) for the on-chain vault enumeration."
+  },
+  instructions: [],
+  accounts: [
+    {
+      name: "Dex",
+      discriminator: [
+        236,
+        30,
+        181,
+        80,
+        209,
+        217,
+        25,
+        163
+      ]
     },
-    loan: {
-      assets: [{ underlying: bor.address, decimals: bor.decimals }],
-      dex: null,
-      perShare: null
+    {
+      name: "TokenReserve",
+      discriminator: [
+        21,
+        18,
+        59,
+        135,
+        120,
+        20,
+        31,
+        12
+      ]
+    },
+    {
+      name: "UserBorrowPosition",
+      discriminator: [
+        73,
+        126,
+        65,
+        123,
+        220,
+        126,
+        197,
+        24
+      ]
+    },
+    {
+      name: "UserSupplyPosition",
+      discriminator: [
+        202,
+        219,
+        136,
+        118,
+        61,
+        177,
+        21,
+        146
+      ]
+    },
+    {
+      name: "VaultAdmin",
+      discriminator: [
+        88,
+        97,
+        160,
+        117,
+        102,
+        39,
+        103,
+        44
+      ]
+    },
+    {
+      name: "VaultConfig",
+      discriminator: [
+        99,
+        86,
+        43,
+        216,
+        184,
+        102,
+        119,
+        77
+      ]
+    },
+    {
+      name: "VaultState",
+      discriminator: [
+        228,
+        196,
+        82,
+        165,
+        98,
+        210,
+        235,
+        152
+      ]
+    },
+    {
+      name: "Oracle",
+      discriminator: [
+        139,
+        194,
+        131,
+        179,
+        140,
+        179,
+        229,
+        244
+      ]
     }
-  };
-  const jupiterLendVault = {
-    market,
-    vaultId: v.id,
-    address: v.address,
-    type: v.type,
-    supplyToken: sup.address,
-    borrowToken: bor.address,
-    supplyDecimals: sup.decimals,
-    borrowDecimals: bor.decimals,
-    collateralFactor: num(v.collateralFactor),
-    liquidationThreshold: num(v.liquidationThreshold),
-    liquidationMaxLimit: num(v.liquidationMaxLimit),
-    withdrawalGap: num(v.withdrawalGap),
-    liquidationPenalty: num(v.liquidationPenalty),
-    borrowFee: num(v.borrowFee),
-    supplyRateMagnifier: num(v.supplyRateMagnifier),
-    borrowRateMagnifier: num(v.borrowRateMagnifier),
-    supplyRateLiquidity: num(v.supplyRateLiquidity),
-    borrowRateLiquidity: num(v.borrowRateLiquidity),
-    minimumBorrowing: v.minimumBorrowing,
-    totalPositions: v.totalPositions,
-    borrowLimit: v.borrowLimit,
-    borrowable: v.borrowable,
-    withdrawLimit: v.withdrawLimit,
-    withdrawable: v.withdrawable,
-    oracle: v.oracle,
-    oraclePrice: v.oraclePrice,
-    oraclePriceOperate: v.oraclePriceOperate,
-    oraclePriceLiquidate: v.oraclePriceLiquidate,
-    oracleSources: v.oracleSources,
-    oracleTimestamp: v.oracleTimestamp,
-    liquiditySupplyData: v.liquiditySupplyData,
-    liquidityBorrowData: v.liquidityBorrowData,
-    topTick: v.topTick,
-    metadata: v.metadata
-  };
-  return {
-    lenderKey,
-    chainId: SOLANA_CHAIN_ID,
-    data: { [colUid]: collateralLeg, [debtUid]: debtLeg },
-    params: { vault, jupiterLendVault }
-  };
-}
+  ],
+  types: [
+    {
+      name: "Dex",
+      docs: [
+        "Core DEX pool state. One per trading pair.",
+        "Uses zero_copy for efficient access without deserialization overhead."
+      ],
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "dex_id",
+            type: "u16"
+          },
+          {
+            name: "re_entrancy",
+            type: "u8"
+          },
+          {
+            name: "token_0",
+            type: "pubkey"
+          },
+          {
+            name: "token_1",
+            type: "pubkey"
+          },
+          {
+            name: "token_0_decimals",
+            type: "u8"
+          },
+          {
+            name: "token_1_decimals",
+            type: "u8"
+          },
+          {
+            name: "last_to_last_stored_price",
+            type: "u128"
+          },
+          {
+            name: "last_stored_price",
+            type: "u128"
+          },
+          {
+            name: "center_price",
+            type: "u128"
+          },
+          {
+            name: "last_update_timestamp",
+            type: "u64"
+          },
+          {
+            name: "last_update_slot",
+            type: "u64"
+          },
+          {
+            name: "is_smart_collateral_enabled",
+            type: "u8"
+          },
+          {
+            name: "is_smart_debt_enabled",
+            type: "u8"
+          },
+          {
+            name: "fee",
+            type: "u32"
+          },
+          {
+            name: "revenue_cut",
+            type: "u8"
+          },
+          {
+            name: "percent_change_active",
+            type: "u8"
+          },
+          {
+            name: "upper_percent",
+            type: "u32"
+          },
+          {
+            name: "lower_percent",
+            type: "u32"
+          },
+          {
+            name: "threshold_change_active",
+            type: "u8"
+          },
+          {
+            name: "upper_shift_threshold_percent",
+            type: "u16"
+          },
+          {
+            name: "lower_shift_threshold_percent",
+            type: "u16"
+          },
+          {
+            name: "shifting_time",
+            type: "u32"
+          },
+          {
+            name: "center_price_address",
+            type: "pubkey"
+          },
+          {
+            name: "max_center_price",
+            type: "u64"
+          },
+          {
+            name: "min_center_price",
+            type: "u64"
+          },
+          {
+            name: "token_0_max_utilization",
+            type: "u16"
+          },
+          {
+            name: "token_1_max_utilization",
+            type: "u16"
+          },
+          {
+            name: "is_center_price_shift_active",
+            type: "u8"
+          },
+          {
+            name: "swap_and_arbitrage_paused",
+            type: "u8"
+          },
+          {
+            name: "total_supply_shares",
+            type: "u64"
+          },
+          {
+            name: "max_supply_shares",
+            type: "u64"
+          },
+          {
+            name: "total_borrow_shares",
+            type: "u64"
+          },
+          {
+            name: "max_borrow_shares",
+            type: "u64"
+          },
+          {
+            name: "range_old_upper_shift",
+            type: "u32"
+          },
+          {
+            name: "range_old_lower_shift",
+            type: "u32"
+          },
+          {
+            name: "range_shift_duration",
+            type: "u32"
+          },
+          {
+            name: "range_shift_start_timestamp",
+            type: "u32"
+          },
+          {
+            name: "threshold_old_upper_shift",
+            type: "u16"
+          },
+          {
+            name: "threshold_old_lower_shift",
+            type: "u16"
+          },
+          {
+            name: "threshold_shift_duration",
+            type: "u32"
+          },
+          {
+            name: "threshold_shift_start_timestamp",
+            type: "u32"
+          },
+          {
+            name: "threshold_shift_old_timestamp",
+            type: "u32"
+          },
+          {
+            name: "center_price_shift_start_timestamp",
+            type: "u32"
+          },
+          {
+            name: "center_price_shift_percent",
+            type: "u32"
+          },
+          {
+            name: "center_price_shift_time",
+            type: "u32"
+          },
+          {
+            name: "_reserved",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "TokenReserve",
+      docs: [
+        "Token configuration and exchange prices"
+      ],
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "borrow_rate",
+            type: "u16"
+          },
+          {
+            name: "fee_on_interest",
+            type: "u16"
+          },
+          {
+            name: "last_utilization",
+            type: "u16"
+          },
+          {
+            name: "last_update_timestamp",
+            type: "u64"
+          },
+          {
+            name: "supply_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "borrow_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "max_utilization",
+            type: "u16"
+          },
+          {
+            name: "total_supply_with_interest",
+            type: "u64"
+          },
+          {
+            name: "total_supply_interest_free",
+            type: "u64"
+          },
+          {
+            name: "total_borrow_with_interest",
+            type: "u64"
+          },
+          {
+            name: "total_borrow_interest_free",
+            type: "u64"
+          },
+          {
+            name: "total_claim_amount",
+            type: "u64"
+          },
+          {
+            name: "interacting_protocol",
+            type: "pubkey"
+          },
+          {
+            name: "interacting_timestamp",
+            type: "u64"
+          },
+          {
+            name: "interacting_balance",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "UserBorrowPosition",
+      docs: [
+        "User borrow position"
+      ],
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "protocol",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "with_interest",
+            type: "u8"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "debt_ceiling",
+            type: "u64"
+          },
+          {
+            name: "last_update",
+            type: "u64"
+          },
+          {
+            name: "expand_pct",
+            type: "u16"
+          },
+          {
+            name: "expand_duration",
+            type: "u32"
+          },
+          {
+            name: "base_debt_ceiling",
+            type: "u64"
+          },
+          {
+            name: "max_debt_ceiling",
+            type: "u64"
+          },
+          {
+            name: "status",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "UserSupplyPosition",
+      docs: [
+        "User supply position"
+      ],
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "protocol",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "with_interest",
+            type: "u8"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "withdrawal_limit",
+            type: "u64"
+          },
+          {
+            name: "decay_amount",
+            type: "u64"
+          },
+          {
+            name: "last_update",
+            type: "u64"
+          },
+          {
+            name: "expand_pct",
+            type: "u16"
+          },
+          {
+            name: "expand_duration",
+            type: "u32"
+          },
+          {
+            name: "decay_duration",
+            type: "u32"
+          },
+          {
+            name: "base_withdrawal_limit",
+            type: "u64"
+          },
+          {
+            name: "status",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultAdmin",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "liquidity_program",
+            type: "pubkey"
+          },
+          {
+            name: "next_vault_id",
+            type: "u16"
+          },
+          {
+            name: "auths",
+            type: {
+              vec: "pubkey"
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultConfig",
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault_id",
+            type: "u16"
+          },
+          {
+            name: "supply_rate_magnifier",
+            type: "i16"
+          },
+          {
+            name: "borrow_rate_magnifier",
+            type: "i16"
+          },
+          {
+            name: "collateral_factor",
+            type: "u16"
+          },
+          {
+            name: "liquidation_threshold",
+            type: "u16"
+          },
+          {
+            name: "liquidation_max_limit",
+            type: "u16"
+          },
+          {
+            name: "withdraw_gap",
+            type: "u16"
+          },
+          {
+            name: "liquidation_penalty",
+            type: "u16"
+          },
+          {
+            name: "borrow_fee",
+            type: "u8"
+          },
+          {
+            name: "vault_type",
+            type: "u8"
+          },
+          {
+            name: "oracle",
+            type: "pubkey"
+          },
+          {
+            name: "rebalancer",
+            type: "pubkey"
+          },
+          {
+            name: "liquidity_program",
+            type: "pubkey"
+          },
+          {
+            name: "oracle_program",
+            type: "pubkey"
+          },
+          {
+            name: "supply_token",
+            type: "pubkey"
+          },
+          {
+            name: "borrow_token",
+            type: "pubkey"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultState",
+      serialization: "bytemuck",
+      repr: {
+        kind: "c",
+        packed: true
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault_id",
+            type: "u16"
+          },
+          {
+            name: "branch_liquidated",
+            type: "u8"
+          },
+          {
+            name: "topmost_tick",
+            type: "i32"
+          },
+          {
+            name: "current_branch_id",
+            type: "u32"
+          },
+          {
+            name: "total_branch_id",
+            type: "u32"
+          },
+          {
+            name: "total_supply",
+            type: "u64"
+          },
+          {
+            name: "total_borrow",
+            type: "u64"
+          },
+          {
+            name: "total_positions",
+            type: "u32"
+          },
+          {
+            name: "absorbed_debt_amount",
+            type: "u128"
+          },
+          {
+            name: "absorbed_col_amount",
+            type: "u128"
+          },
+          {
+            name: "absorbed_dust_debt",
+            type: "u64"
+          },
+          {
+            name: "liquidity_supply_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "liquidity_borrow_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "vault_supply_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "vault_borrow_exchange_price",
+            type: "u64"
+          },
+          {
+            name: "next_position_id",
+            type: "u32"
+          },
+          {
+            name: "last_update_timestamp",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Oracle",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "nonce",
+            type: "u16"
+          },
+          {
+            name: "sources",
+            type: {
+              vec: {
+                defined: {
+                  name: "Sources"
+                }
+              }
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "Sources",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "source",
+            type: "pubkey"
+          },
+          {
+            name: "invert",
+            type: "bool"
+          },
+          {
+            name: "multiplier",
+            type: "u128"
+          },
+          {
+            name: "divisor",
+            type: "u128"
+          },
+          {
+            name: "source_type",
+            type: {
+              defined: {
+                name: "SourceType"
+              }
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "SourceType",
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "Pyth"
+          },
+          {
+            name: "StakePool"
+          },
+          {
+            name: "MsolPool"
+          },
+          {
+            name: "Redstone"
+          },
+          {
+            name: "Chainlink"
+          },
+          {
+            name: "SinglePool"
+          },
+          {
+            name: "JupLend"
+          },
+          {
+            name: "ChainlinkDataStreams"
+          },
+          {
+            name: "PstPool"
+          },
+          {
+            name: "DexSmartColPegOracle"
+          },
+          {
+            name: "DexSmartDebtPegOracle"
+          }
+        ]
+      }
+    }
+  ]
+};
 
 // src/lending/public-data/jupiter-lend/flashloan.ts
 import {
@@ -9672,38 +10254,885 @@ function decodeJupFlashloanAdmin(data) {
     activeAmount: BigInt(a.active_flashloan_amount)
   };
 }
-async function readJupFlashloanAdmin(rpc, market = "main") {
-  const address = await jupFlashloanAdmin(market);
-  const { accounts } = await rpc.readAccounts([address], { encoding: "base64" });
-  const a = accounts[0];
-  if (!a || a.owner !== JUP_FLASHLOAN_PROGRAMS[market]) return null;
-  return decodeJupFlashloanAdmin(fromBase642(a.data[0]));
+async function readJupFlashloanAdmin(rpc, market = "main") {
+  const address = await jupFlashloanAdmin(market);
+  const { accounts } = await rpc.readAccounts([address], { encoding: "base64" });
+  const a = accounts[0];
+  if (!a || a.owner !== JUP_FLASHLOAN_PROGRAMS[market]) return null;
+  return decodeJupFlashloanAdmin(fromBase642(a.data[0]));
+}
+async function readJupFlashAssets(rpc, market = "main") {
+  const admin = await jupFlashloanAdmin(market);
+  const rows = await rpc.call(
+    "getProgramAccounts",
+    [
+      JUP_LIQUIDITY_PROGRAMS[market],
+      {
+        encoding: "base64",
+        dataSlice: { offset: 40, length: 32 },
+        filters: [{ memcmp: { offset: 8, bytes: admin } }]
+      }
+    ],
+    { accounts: 1 }
+  );
+  const mints = /* @__PURE__ */ new Set();
+  for (const r of rows) mints.add(encodeBase582(fromBase642(r.account.data[0])));
+  return [...mints];
+}
+async function readJupFlashAvailable(rpc, mint, tokenProgram, market = "main") {
+  const vault = await jupLiquidityVault(mint, tokenProgram, market);
+  const r = await rpc.call(
+    "getTokenAccountBalance",
+    [vault]
+  );
+  return BigInt(r.value.amount);
+}
+
+// src/lending/public-data/jupiter-lend/onchain.ts
+var JL_VAULTS_ACCOUNTS_IDL = vaults_accounts_default;
+var JUP_VAULTS_PROGRAMS = {
+  main: "jupr81YtYssSyPt8jbnGuiWon5f6x9TcDEFxYe3Bdzi",
+  ethena: "jupo974WCqAUMD3RtpayTap1me7StQCWtEkBbDb6Ba3"
+};
+var JUP_DEX_PROGRAM = "jupZ4m2GqUCJ5iueMfzQf8khFfH31d4XAQt3RzCT9Vd";
+var JL_EXCHANGE_PRICES_PRECISION = 10n ** 12n;
+var RATE_OUTPUT = 10n ** 18n;
+var SCALE_FACTOR = 10n ** 18n;
+var FOUR_DECIMALS = 10000n;
+var SECONDS_PER_YEAR = 31536000n;
+var DEFAULT_MAX_UTILIZATION = 9500n;
+var JL_VAULT_AMOUNT_DECIMALS = 9;
+var isJlSmartCol = (t) => t === 2 || t === 4;
+var isJlSmartDebt = (t) => t === 3 || t === 4;
+var utf83 = (s) => new TextEncoder().encode(s);
+var u16le = (n) => new Uint8Array([n & 255, n >> 8 & 255]);
+var big = (v) => BigInt(v ?? 0);
+var maxB = (a, b) => a > b ? a : b;
+var minB = (a, b) => a < b ? a : b;
+var jlVaultConfigPda = async (vaultId, market = "main") => (await findProgramAddress3(
+  [utf83("vault_config"), u16le(vaultId)],
+  JUP_VAULTS_PROGRAMS[market]
+)).address;
+var jlVaultStatePda = async (vaultId, market = "main") => (await findProgramAddress3(
+  [utf83("vault_state"), u16le(vaultId)],
+  JUP_VAULTS_PROGRAMS[market]
+)).address;
+var jlVaultAdminPda = async (market = "main") => (await findProgramAddress3([utf83("vault_admin")], JUP_VAULTS_PROGRAMS[market])).address;
+var liq = async (seeds, market) => (await findProgramAddress3(seeds, JUP_LIQUIDITY_PROGRAMS[market])).address;
+var pk3 = async (a) => {
+  const b = decodeBase583(a);
+  if (!b || b.length !== 32) throw new Error(`not a pubkey: ${a}`);
+  return b;
+};
+var dec = (name, data) => decodeIdlAccount3(JL_VAULTS_ACCOUNTS_IDL, name, fromBase643(data));
+var ratio = (withInterest, free) => {
+  if (withInterest > free) return [free * FOUR_DECIMALS / withInterest, false];
+  if (withInterest < free) return [withInterest * FOUR_DECIMALS / free, true];
+  return [withInterest > 0n ? FOUR_DECIMALS : 0n, false];
+};
+function jlLiquidityExchangePrices(r, now) {
+  let supplyEx = big(r.supply_exchange_price);
+  let borrowEx = big(r.borrow_exchange_price);
+  const borrowRate = BigInt(r.borrow_rate);
+  const dt = now - big(r.last_update_timestamp);
+  if (supplyEx === 0n || borrowEx === 0n || dt <= 0n || borrowRate === 0n)
+    return { supplyEx, borrowEx };
+  borrowEx += borrowEx * borrowRate * dt / (SECONDS_PER_YEAR * FOUR_DECIMALS);
+  const [supplyRatio, supplyInverse] = ratio(
+    big(r.total_supply_with_interest),
+    big(r.total_supply_interest_free)
+  );
+  const [borrowRatio, borrowInverse] = ratio(
+    big(r.total_borrow_with_interest),
+    big(r.total_borrow_interest_free)
+  );
+  if (borrowRatio === 1n) return { supplyEx, borrowEx };
+  if (supplyInverse && supplyRatio === 0n) return { supplyEx, borrowEx };
+  const util = BigInt(r.last_utilization);
+  let ratioSupplyYield = supplyInverse ? util * (RATE_OUTPUT + RATE_OUTPUT * FOUR_DECIMALS / supplyRatio) / FOUR_DECIMALS : util * RATE_OUTPUT * (FOUR_DECIMALS + supplyRatio) / (FOUR_DECIMALS * FOUR_DECIMALS);
+  const adjBorrowRatio = borrowInverse ? borrowRatio * RATE_OUTPUT / (FOUR_DECIMALS + borrowRatio) : RATE_OUTPUT - borrowRatio * RATE_OUTPUT / (FOUR_DECIMALS + borrowRatio);
+  ratioSupplyYield = ratioSupplyYield * adjBorrowRatio * FOUR_DECIMALS / RATE_OUTPUT / RATE_OUTPUT;
+  const supplyRate = borrowRate * ratioSupplyYield * (FOUR_DECIMALS - BigInt(r.fee_on_interest));
+  supplyEx += supplyEx * supplyRate * dt / (SECONDS_PER_YEAR * FOUR_DECIMALS) / (FOUR_DECIMALS * FOUR_DECIMALS);
+  return { supplyEx, borrowEx };
+}
+function jlOverallTokenData(r, now) {
+  const { supplyEx, borrowEx } = jlLiquidityExchangePrices(r, now);
+  const supplyRaw = big(r.total_supply_with_interest);
+  const borrowRaw = big(r.total_borrow_with_interest);
+  const totalSupply = supplyRaw * supplyEx / JL_EXCHANGE_PRICES_PRECISION + big(r.total_supply_interest_free);
+  const totalBorrow = borrowRaw * borrowEx / JL_EXCHANGE_PRICES_PRECISION + big(r.total_borrow_interest_free);
+  let supplyRate = 0n;
+  if (supplyRaw > 0n) {
+    const b = borrowRaw * big(r.borrow_exchange_price) / JL_EXCHANGE_PRICES_PRECISION;
+    const s = supplyRaw * big(r.supply_exchange_price) / JL_EXCHANGE_PRICES_PRECISION;
+    if (s > 0n)
+      supplyRate = BigInt(r.borrow_rate) * (FOUR_DECIMALS - BigInt(r.fee_on_interest)) * b / (s * FOUR_DECIMALS);
+  }
+  const maxUtil = BigInt(r.max_utilization) || DEFAULT_MAX_UTILIZATION;
+  return {
+    supplyEx,
+    borrowEx,
+    totalSupply,
+    totalBorrow,
+    supplyRate,
+    borrowRate: BigInt(r.borrow_rate),
+    maxUtilization: maxUtil
+  };
+}
+function jlUserSupplyData(u, o, balance, now) {
+  const z = {
+    modeWithInterest: false,
+    supply: 0n,
+    withdrawalLimit: 0n,
+    lastUpdateTimestamp: 0n,
+    expandPercent: 0n,
+    expandDuration: 0n,
+    baseWithdrawalLimit: 0n,
+    withdrawableUntilLimit: 0n,
+    withdrawable: 0n,
+    decayAmount: 0n,
+    decayEndTimestamp: 0n
+  };
+  if (!u) return z;
+  const amount = big(u.amount);
+  const expandPct = BigInt(u.expand_pct);
+  const expandDuration = BigInt(u.expand_duration);
+  const last = big(u.last_update);
+  let limit = 0n;
+  const lastLimit = big(u.withdrawal_limit);
+  if (lastLimit > 0n) {
+    const maxWithdrawable = amount * expandPct / FOUR_DECIMALS;
+    const expanded = expandDuration > 0n ? maxWithdrawable * (now - last) / expandDuration : maxWithdrawable;
+    limit = lastLimit > expanded ? lastLimit - expanded : 0n;
+    const floor = amount - maxWithdrawable;
+    if (floor > limit) limit = floor;
+  }
+  let decay = big(u.decay_amount);
+  let decayEnd = now;
+  const decayDuration = BigInt(u.decay_duration);
+  if (decay > 0n && decayDuration > 0n) {
+    const elapsed = now - last;
+    if (elapsed < decayDuration) {
+      decay -= decay * elapsed / decayDuration;
+      decayEnd = last + decayDuration;
+    } else decay = 0n;
+  }
+  const withInterest = !!u.with_interest;
+  const ex = (v) => withInterest ? v * o.supplyEx / JL_EXCHANGE_PRICES_PRECISION : v;
+  const supply = ex(amount);
+  let withdrawalLimit = ex(limit);
+  const untilLimit = supply > withdrawalLimit ? supply - withdrawalLimit : 0n;
+  if (withdrawalLimit === 0n) withdrawalLimit = supply;
+  return {
+    modeWithInterest: withInterest,
+    supply,
+    withdrawalLimit,
+    lastUpdateTimestamp: last,
+    expandPercent: expandPct,
+    expandDuration,
+    baseWithdrawalLimit: ex(big(u.base_withdrawal_limit)),
+    withdrawableUntilLimit: untilLimit,
+    withdrawable: minB(balance, untilLimit),
+    decayAmount: ex(decay),
+    decayEndTimestamp: decayEnd
+  };
+}
+function jlUserBorrowData(u, o, balance, now) {
+  const z = {
+    modeWithInterest: false,
+    borrow: 0n,
+    borrowLimit: 0n,
+    lastUpdateTimestamp: 0n,
+    expandPercent: 0n,
+    expandDuration: 0n,
+    baseBorrowLimit: 0n,
+    maxBorrowLimit: 0n,
+    borrowLimitUtilization: 0n,
+    borrowableUntilLimit: 0n,
+    borrowable: 0n
+  };
+  if (!u) return z;
+  const amount = big(u.amount);
+  const expandPct = BigInt(u.expand_pct);
+  const expandDuration = BigInt(u.expand_duration);
+  const last = big(u.last_update);
+  const base = big(u.base_debt_ceiling);
+  const maxCeil = big(u.max_debt_ceiling);
+  let limit;
+  if (now < last || expandDuration === 0n) limit = base;
+  else {
+    const maxExpansion = amount * expandPct / FOUR_DECIMALS;
+    limit = maxExpansion * (now - last) / expandDuration + big(u.debt_ceiling);
+    limit = minB(limit, amount + maxExpansion);
+    limit = maxB(limit, base);
+    limit = minB(limit, maxCeil);
+  }
+  const withInterest = !!u.with_interest;
+  const ex = (v) => withInterest ? v * o.borrowEx / JL_EXCHANGE_PRICES_PRECISION : v;
+  const borrow = ex(amount);
+  const borrowLimit = ex(limit);
+  const borrowLimitUtilization = o.maxUtilization * o.totalSupply / FOUR_DECIMALS;
+  const untilUtil = borrowLimitUtilization > o.totalBorrow ? borrowLimitUtilization - o.totalBorrow : 0n;
+  const untilLimit = borrowLimit > borrow ? borrowLimit - borrow : 0n;
+  const borrowableUntilLimit = minB(untilLimit, untilUtil);
+  return {
+    modeWithInterest: withInterest,
+    borrow,
+    borrowLimit,
+    lastUpdateTimestamp: last,
+    expandPercent: expandPct,
+    expandDuration,
+    baseBorrowLimit: ex(base),
+    maxBorrowLimit: ex(maxCeil),
+    borrowLimitUtilization,
+    borrowableUntilLimit,
+    borrowable: minB(balance, borrowableUntilLimit)
+  };
+}
+function jlVaultExchangePrices(s, c, liqSupplyEx, liqBorrowEx, now) {
+  const oldLs = big(s.liquidity_supply_exchange_price);
+  const oldLb = big(s.liquidity_borrow_exchange_price);
+  const vs = big(s.vault_supply_exchange_price);
+  const vb = big(s.vault_borrow_exchange_price);
+  if (liqSupplyEx < oldLs || liqBorrowEx < oldLb || oldLs === 0n || oldLb === 0n)
+    return { supplyEx: vs, borrowEx: vb };
+  const dt = maxB(0n, now - big(s.last_update_timestamp));
+  let supplyEx = vs * (liqSupplyEx * SCALE_FACTOR / oldLs) / SCALE_FACTOR;
+  const sm = BigInt(c.supply_rate_magnifier);
+  if (sm !== 0n) {
+    const ch = vs * dt * (sm < 0n ? -sm : sm) / FOUR_DECIMALS / SECONDS_PER_YEAR;
+    supplyEx = sm > 0n ? supplyEx + ch : supplyEx - ch;
+  }
+  const prod = vb * (liqBorrowEx * SCALE_FACTOR / oldLb);
+  let borrowEx = (prod + SCALE_FACTOR - 1n) / SCALE_FACTOR;
+  const bm = BigInt(c.borrow_rate_magnifier);
+  if (bm !== 0n) {
+    const ch = vb * dt * (bm < 0n ? -bm : bm) / FOUR_DECIMALS / SECONDS_PER_YEAR;
+    borrowEx = bm > 0n ? borrowEx + ch : borrowEx - ch;
+  }
+  return { supplyEx, borrowEx };
+}
+var jlVaultToRaw = (v, decimals) => decimals >= JL_VAULT_AMOUNT_DECIMALS ? v * 10n ** BigInt(decimals - JL_VAULT_AMOUNT_DECIMALS) : v / 10n ** BigInt(JL_VAULT_AMOUNT_DECIMALS - decimals);
+async function read(rpc, keys) {
+  const uniq = [...new Set(keys)];
+  const { accounts, slot } = await rpc.readAccounts(uniq, {
+    encoding: "base64"
+  });
+  const m = /* @__PURE__ */ new Map();
+  uniq.forEach((k, i) => m.set(k, accounts[i] ?? null));
+  return { m, slot };
+}
+async function readJlNextVaultId(rpc, market = "main") {
+  const admin = await jlVaultAdminPda(market);
+  const { m } = await read(rpc, [admin]);
+  const a = m.get(admin);
+  if (!a || a.owner !== JUP_VAULTS_PROGRAMS[market]) return void 0;
+  return Number(
+    dec("VaultAdmin", a.data[0]).next_vault_id
+  );
 }
-async function readJupFlashAssets(rpc, market = "main") {
-  const admin = await jupFlashloanAdmin(market);
-  const rows = await rpc.call(
-    "getProgramAccounts",
-    [
-      JUP_LIQUIDITY_PROGRAMS[market],
-      {
-        encoding: "base64",
-        dataSlice: { offset: 40, length: 32 },
-        filters: [{ memcmp: { offset: 8, bytes: admin } }]
-      }
-    ],
-    { accounts: 1 }
+var sourceTypeName = (t) => {
+  if (typeof t === "string") return t;
+  if (t && typeof t === "object") return Object.keys(t)[0] ?? "unknown";
+  return String(t);
+};
+var lowerFirst = (s) => s.charAt(0).toLowerCase() + s.slice(1);
+async function readJupiterLendVaultsOnchain(rpc, market, vaultIds, opts = {}) {
+  if (!vaultIds.length) return [];
+  const now = BigInt(opts.now ?? Math.floor(Date.now() / 1e3));
+  const program = JUP_VAULTS_PROGRAMS[market];
+  const cfgKeys = await Promise.all(
+    vaultIds.map((i) => jlVaultConfigPda(i, market))
+  );
+  const stateKeys = await Promise.all(
+    vaultIds.map((i) => jlVaultStatePda(i, market))
   );
+  const r1 = await read(rpc, [...cfgKeys, ...stateKeys]);
+  const items = [];
+  vaultIds.forEach((id, k) => {
+    const ca = r1.m.get(cfgKeys[k]);
+    const sa = r1.m.get(stateKeys[k]);
+    if (!ca || !sa || ca.owner !== program || sa.owner !== program) return;
+    try {
+      const c = dec("VaultConfig", ca.data[0]);
+      const s = dec("VaultState", sa.data[0]);
+      const t = Number(c.vault_type);
+      items.push({
+        id,
+        configKey: cfgKeys[k],
+        c,
+        s,
+        smartCol: isJlSmartCol(t),
+        smartDebt: isJlSmartDebt(t)
+      });
+    } catch (e) {
+      console.warn(
+        `[jupiter-lend] vault ${market}_${id}: ${e.message}`
+      );
+    }
+  });
+  if (!items.length) return [];
   const mints = /* @__PURE__ */ new Set();
-  for (const r of rows) mints.add(encodeBase582(fromBase642(r.account.data[0])));
-  return [...mints];
-}
-async function readJupFlashAvailable(rpc, mint, tokenProgram, market = "main") {
-  const vault = await jupLiquidityVault(mint, tokenProgram, market);
-  const r = await rpc.call(
-    "getTokenAccountBalance",
-    [vault]
+  const dexes = /* @__PURE__ */ new Set();
+  const r2Keys = [];
+  const reserveOf = /* @__PURE__ */ new Map();
+  const supplyPosOf = /* @__PURE__ */ new Map();
+  const borrowPosOf = /* @__PURE__ */ new Map();
+  for (const it of items) {
+    r2Keys.push(it.c.oracle);
+    const sides = [
+      [it.c.supply_token, it.smartCol, "supply"],
+      [it.c.borrow_token, it.smartDebt, "borrow"]
+    ];
+    for (const [token, smart, side] of sides) {
+      if (smart) {
+        dexes.add(token);
+        continue;
+      }
+      mints.add(token);
+      if (!reserveOf.has(token))
+        reserveOf.set(
+          token,
+          await liq([utf83("reserve"), await pk3(token)], market)
+        );
+      const pos = await liq(
+        [
+          utf83(
+            side === "supply" ? "user_supply_position" : "user_borrow_position"
+          ),
+          await pk3(token),
+          await pk3(it.configKey)
+        ],
+        market
+      );
+      (side === "supply" ? supplyPosOf : borrowPosOf).set(
+        `${it.id}:${token}`,
+        pos
+      );
+    }
+  }
+  r2Keys.push(
+    ...mints,
+    ...dexes,
+    ...reserveOf.values(),
+    ...supplyPosOf.values(),
+    ...borrowPosOf.values()
   );
-  return BigInt(r.value.amount);
+  const r2 = await read(rpc, r2Keys);
+  const decimalsOf = /* @__PURE__ */ new Map();
+  for (const mint of mints) {
+    const a = r2.m.get(mint);
+    if (!a) continue;
+    const b = fromBase643(a.data[0]);
+    if (b.length >= 45) decimalsOf.set(mint, b[44]);
+  }
+  const reserves = /* @__PURE__ */ new Map();
+  for (const [mint, key2] of reserveOf) {
+    const a = r2.m.get(key2);
+    if (!a) continue;
+    try {
+      reserves.set(mint, dec("TokenReserve", a.data[0]));
+    } catch (e) {
+      console.warn(`[jupiter-lend] reserve ${mint}: ${e.message}`);
+    }
+  }
+  const vaultOf = /* @__PURE__ */ new Map();
+  for (const [mint, r] of reserves) vaultOf.set(mint, r.vault);
+  const r3 = vaultOf.size ? await read(rpc, [...vaultOf.values()]) : { m: /* @__PURE__ */ new Map(), slot: r2.slot };
+  const balanceOf = (mint) => {
+    const a = r3.m.get(vaultOf.get(mint) ?? "");
+    if (!a) return 0n;
+    const b = fromBase643(a.data[0]);
+    return b.length >= 72 ? new DataView(b.buffer, b.byteOffset, b.byteLength).getBigUint64(
+      64,
+      true
+    ) : 0n;
+  };
+  const overall = /* @__PURE__ */ new Map();
+  for (const [mint, r] of reserves)
+    overall.set(mint, jlOverallTokenData(r, now));
+  const dexOf = (address) => {
+    const a = r2.m.get(address);
+    if (!a) return void 0;
+    try {
+      const d2 = dec("Dex", a.data[0]);
+      return { address, token0: d2.token_0, token1: d2.token_1 };
+    } catch {
+      return void 0;
+    }
+  };
+  const tokenFact = (mint, decimals) => {
+    const known = opts.tokens?.[mint];
+    if (known) return known;
+    const l = opts.tokenList?.[mint];
+    const sym = l?.symbol ?? mint.slice(0, 4);
+    return {
+      address: mint,
+      chainId: "solana",
+      name: l?.name ?? sym,
+      symbol: sym,
+      uiSymbol: sym,
+      decimals: l?.decimals ?? decimals,
+      ...typeof l?.logoURI === "string" ? { logoUrl: l.logoURI } : {},
+      // unpriced: the converter's USD figures read 0 — say so on the bundle, never invent
+      price: "0"
+    };
+  };
+  const dexToken = (d2, address) => {
+    const s = (m) => opts.tokens?.[m]?.uiSymbol ?? opts.tokenList?.[m]?.symbol ?? m.slice(0, 4);
+    const sym = d2 ? `${s(d2.token0)}-${s(d2.token1)} DEX` : `DEX ${address.slice(0, 4)}`;
+    return {
+      address,
+      chainId: "solana",
+      name: `Jupiter Lend ${sym} shares`,
+      symbol: sym,
+      uiSymbol: sym,
+      decimals: JL_VAULT_AMOUNT_DECIMALS,
+      price: "0"
+    };
+  };
+  const out = [];
+  for (const it of items) {
+    const { c, s } = it;
+    const supTok = c.supply_token;
+    const borTok = c.borrow_token;
+    const supO = it.smartCol ? void 0 : overall.get(supTok);
+    const borO = it.smartDebt ? void 0 : overall.get(borTok);
+    if (!it.smartCol && !supO || !it.smartDebt && !borO) {
+      console.warn(
+        `[jupiter-lend] vault ${market}_${it.id}: layer reserve not readable, skipped`
+      );
+      continue;
+    }
+    const supDec = it.smartCol ? JL_VAULT_AMOUNT_DECIMALS : decimalsOf.get(supTok) ?? 9;
+    const borDec = it.smartDebt ? JL_VAULT_AMOUNT_DECIMALS : decimalsOf.get(borTok) ?? 9;
+    const zero = {
+      supplyEx: JL_EXCHANGE_PRICES_PRECISION,
+      borrowEx: JL_EXCHANGE_PRICES_PRECISION,
+      totalSupply: 0n,
+      totalBorrow: 0n,
+      supplyRate: 0n,
+      borrowRate: 0n,
+      maxUtilization: DEFAULT_MAX_UTILIZATION
+    };
+    const so = supO ?? zero;
+    const bo = borO ?? zero;
+    const supBal = it.smartCol ? 0n : balanceOf(supTok);
+    const borBal = it.smartDebt ? 0n : balanceOf(borTok);
+    const us = (() => {
+      const a = r2.m.get(supplyPosOf.get(`${it.id}:${supTok}`) ?? "");
+      return a ? dec("UserSupplyPosition", a.data[0]) : void 0;
+    })();
+    const ub = (() => {
+      const a = r2.m.get(borrowPosOf.get(`${it.id}:${borTok}`) ?? "");
+      return a ? dec("UserBorrowPosition", a.data[0]) : void 0;
+    })();
+    const sup = jlUserSupplyData(it.smartCol ? void 0 : us, so, supBal, now);
+    const bor = jlUserBorrowData(it.smartDebt ? void 0 : ub, bo, borBal, now);
+    const ex = jlVaultExchangePrices(
+      s,
+      c,
+      it.smartCol ? JL_EXCHANGE_PRICES_PRECISION : so.supplyEx,
+      it.smartDebt ? JL_EXCHANGE_PRICES_PRECISION : bo.borrowEx,
+      now
+    );
+    const supplyEx = it.smartCol ? big(s.vault_supply_exchange_price) : ex.supplyEx;
+    const borrowEx = it.smartDebt ? big(s.vault_borrow_exchange_price) : ex.borrowEx;
+    const P = JL_EXCHANGE_PRICES_PRECISION;
+    const totalSupply = jlVaultToRaw(
+      big(s.total_supply) * supplyEx / P,
+      supDec
+    );
+    const totalBorrow = jlVaultToRaw(
+      big(s.total_borrow) * borrowEx / P,
+      borDec
+    );
+    const absorbedSupply = jlVaultToRaw(
+      big(s.absorbed_col_amount) * supplyEx / P,
+      supDec
+    );
+    const absorbedBorrow = jlVaultToRaw(
+      big(s.absorbed_debt_amount) * borrowEx / P,
+      borDec
+    );
+    let withdrawLimit = 0n;
+    let withdrawableUntilLimit = 0n;
+    let withdrawable = 0n;
+    if (sup.supply > 0n) {
+      withdrawLimit = sup.withdrawalLimit;
+      const gap = sup.supply * BigInt(c.withdraw_gap) / 1000n;
+      withdrawableUntilLimit = sup.withdrawableUntilLimit > gap ? (sup.withdrawableUntilLimit - gap) * 999999n / 1000000n : 0n;
+      withdrawable = minB(supBal, withdrawableUntilLimit);
+    }
+    let borrowLimit = 0n;
+    let borrowLimitUtilization = 0n;
+    let borrowableUntilLimit = 0n;
+    let borrowable = 0n;
+    if (bor.borrow > 0n) {
+      borrowLimit = bor.borrowLimit;
+      borrowLimitUtilization = bor.borrowLimitUtilization;
+      borrowableUntilLimit = bor.borrowableUntilLimit * 999999n / 1000000n;
+      borrowable = minB(borBal, borrowableUntilLimit);
+    }
+    const minimumBorrowing = jlVaultToRaw(10001n * borrowEx / P, borDec);
+    const supplyRateLiq = it.smartCol ? 0n : so.supplyRate;
+    const borrowRateLiq = it.smartDebt ? 0n : bo.borrowRate;
+    const supplyRate = supplyRateLiq + BigInt(c.supply_rate_magnifier);
+    const borrowRate = borrowRateLiq + BigInt(c.borrow_rate_magnifier);
+    const supplyDex = it.smartCol ? dexOf(supTok) : void 0;
+    const borrowDex = it.smartDebt ? dexOf(borTok) : void 0;
+    const supplyToken = it.smartCol ? dexToken(supplyDex, supTok) : tokenFact(supTok, supDec);
+    const borrowToken = it.smartDebt ? dexToken(borrowDex, borTok) : tokenFact(borTok, borDec);
+    let oracleSources = [];
+    const oa = r2.m.get(c.oracle);
+    if (oa)
+      try {
+        oracleSources = dec("Oracle", oa.data[0]).sources.map(
+          (x) => ({
+            source: x.source,
+            invert: x.invert,
+            multiplier: String(x.multiplier),
+            divisor: String(x.divisor),
+            sourceType: { [lowerFirst(sourceTypeName(x.source_type))]: {} }
+          })
+        );
+      } catch {
+      }
+    const vault = {
+      id: it.id,
+      address: it.configKey,
+      type: Number(c.vault_type),
+      supplyToken,
+      borrowToken,
+      totalSupply: totalSupply.toString(),
+      totalSupplyLiquidity: sup.supply.toString(),
+      totalBorrow: totalBorrow.toString(),
+      totalBorrowLiquidity: bor.borrow.toString(),
+      absorbedSupply: absorbedSupply.toString(),
+      absorbedBorrow: absorbedBorrow.toString(),
+      supplyRateMagnifier: String(c.supply_rate_magnifier),
+      borrowRateMagnifier: String(c.borrow_rate_magnifier),
+      borrowFee: String(c.borrow_fee),
+      collateralFactor: String(c.collateral_factor),
+      liquidationThreshold: String(c.liquidation_threshold),
+      liquidationMaxLimit: String(c.liquidation_max_limit),
+      liquidationPenalty: String(c.liquidation_penalty),
+      withdrawalGap: String(c.withdraw_gap),
+      supplyRate: supplyRate.toString(),
+      supplyRateLiquidity: supplyRateLiq.toString(),
+      borrowRate: borrowRate.toString(),
+      borrowRateLiquidity: borrowRateLiq.toString(),
+      withdrawLimit: withdrawLimit.toString(),
+      withdrawableUntilLimit: withdrawableUntilLimit.toString(),
+      withdrawable: withdrawable.toString(),
+      borrowLimit: borrowLimit.toString(),
+      borrowableUntilLimit: borrowableUntilLimit.toString(),
+      borrowable: borrowable.toString(),
+      borrowLimitUtilization: borrowLimitUtilization.toString(),
+      minimumBorrowing: minimumBorrowing.toString(),
+      totalPositions: Number(s.total_positions),
+      oracle: c.oracle,
+      oraclePrice: "",
+      oraclePriceOperate: "",
+      oraclePriceLiquidate: "",
+      oracleSources,
+      oracleTimestamp: 0,
+      liquiditySupplyData: {
+        modeWithInterest: sup.modeWithInterest,
+        supply: sup.supply.toString(),
+        withdrawalLimit: sup.withdrawalLimit.toString(),
+        lastUpdateTimestamp: sup.lastUpdateTimestamp.toString(),
+        expandPercent: sup.expandPercent.toString(),
+        expandDuration: sup.expandDuration.toString(),
+        baseWithdrawalLimit: sup.baseWithdrawalLimit.toString(),
+        withdrawableUntilLimit: sup.withdrawableUntilLimit.toString(),
+        withdrawable: sup.withdrawable.toString(),
+        decayAmount: sup.decayAmount.toString(),
+        decayEndTimestamp: sup.decayEndTimestamp.toString()
+      },
+      liquidityBorrowData: {
+        modeWithInterest: bor.modeWithInterest,
+        borrow: bor.borrow.toString(),
+        borrowLimit: bor.borrowLimit.toString(),
+        lastUpdateTimestamp: bor.lastUpdateTimestamp.toString(),
+        expandPercent: bor.expandPercent.toString(),
+        expandDuration: bor.expandDuration.toString(),
+        baseBorrowLimit: bor.baseBorrowLimit.toString(),
+        maxBorrowLimit: bor.maxBorrowLimit.toString(),
+        borrowLimitUtilization: bor.borrowLimitUtilization.toString(),
+        borrowableUntilLimit: bor.borrowableUntilLimit.toString(),
+        borrowable: bor.borrowable.toString()
+      },
+      rewards: [],
+      topTick: Number(s.topmost_tick),
+      metadata: { maxLeverage: false, nativeStake: false, pegged: false }
+    };
+    out.push({
+      vault,
+      smartCol: it.smartCol,
+      smartDebt: it.smartDebt,
+      supplyDex,
+      borrowDex,
+      slot: r2.slot
+    });
+  }
+  return out;
+}
+
+// src/lending/public-data/jupiter-lend/convertPublic.ts
+var JL_FACTOR_SCALE = 1e3;
+var JL_BPS = 1e4;
+var JL_ORACLE_DECIMALS = 15;
+var JL_ORACLE_SCALE = 10 ** JL_ORACLE_DECIMALS;
+var FLUID_ORACLE_DECIMALS = 27;
+var FLUID_VAULT_TYPE_T1 = 1e4;
+var bpsToPercent = (v) => num(v) / 100;
+var jlOraclePriceInBorrow = (raw2) => num(raw2) / JL_ORACLE_SCALE;
+function jlOracleToFluidRaw(raw2, colDecimals, debtDecimals) {
+  if (typeof raw2 !== "string" || !/^\d+$/.test(raw2)) return void 0;
+  const exp = FLUID_ORACLE_DECIMALS - JL_ORACLE_DECIMALS + debtDecimals - colDecimals;
+  const v = BigInt(raw2);
+  return (exp >= 0 ? v * 10n ** BigInt(exp) : v / 10n ** BigInt(-exp)).toString();
+}
+function formatRawUnits(raw2, decimals) {
+  let v;
+  try {
+    v = BigInt(raw2 ?? 0);
+  } catch {
+    return "0";
+  }
+  const neg = v < 0n;
+  if (neg) v = -v;
+  const base = 10n ** BigInt(decimals);
+  const whole = v / base;
+  const frac = (v % base).toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
+}
+function deriveLayerTotals(vaults, earn) {
+  const t = {};
+  const slot = (mint, decimals) => t[mint] ??= { supply: 0n, borrow: 0n, decimals };
+  for (const e of earn)
+    slot(e.assetAddress, e.asset.decimals).supply += BigInt(
+      e.liquiditySupplyData.supply || "0"
+    );
+  for (const v of vaults) {
+    slot(v.supplyToken.address, v.supplyToken.decimals).supply += BigInt(
+      v.liquiditySupplyData.supply || "0"
+    );
+    slot(v.borrowToken.address, v.borrowToken.decimals).borrow += BigInt(
+      v.liquidityBorrowData.borrow || "0"
+    );
+  }
+  return t;
+}
+var fmt = (raw2, decimals) => Number(raw2) / 10 ** decimals;
+var jupiterLendCurrency = (t, listed3) => {
+  const base = listed3 ?? {
+    chainId: SOLANA_CHAIN_ID,
+    address: t.address,
+    symbol: t.uiSymbol ?? t.symbol,
+    name: t.name,
+    decimals: t.decimals
+  };
+  return { ...base, assetGroup: base.assetGroup || `solana-${t.address}` };
+};
+function convertJupiterLendVault(market, v, opts = {}) {
+  const lenderKey = jupiterLendVaultKey(market, v.id);
+  const sup = v.supplyToken;
+  const bor = v.borrowToken;
+  const supPrice = num(sup.price);
+  const borPrice = num(bor.price);
+  const ltv = num(v.collateralFactor) / JL_FACTOR_SCALE;
+  const lt = num(v.liquidationThreshold) / JL_FACTOR_SCALE;
+  const penalty = num(v.liquidationPenalty) / JL_BPS;
+  const supAsset = jupiterLendCurrency(sup, opts.tokenList?.[sup.address]);
+  const borAsset = jupiterLendCurrency(bor, opts.tokenList?.[bor.address]);
+  const supSym = supAsset.symbol ?? sup.symbol;
+  const borSym = borAsset.symbol ?? bor.symbol;
+  const label = `${supSym} / ${borSym} \xB7 vault #${v.id}`;
+  const intrinsic = (a) => opts.intrinsicYields?.[a.assetGroup] ?? 0;
+  const layerOf = (mint) => {
+    const l = opts.layer?.[mint];
+    if (!l || l.supply === 0n) return { utilization: 0 };
+    return {
+      utilization: Number(l.borrow * 10000n / l.supply) / 1e4,
+      irmTotalDeposits: fmt(l.supply, l.decimals),
+      irmTotalDebt: fmt(l.borrow, l.decimals)
+    };
+  };
+  const totalSupply = BigInt(v.totalSupply || "0");
+  const withdrawLimit = BigInt(v.withdrawLimit || "0");
+  const lockupRatio = totalSupply > 0n ? Number(withdrawLimit * 10000n / totalSupply) / 1e4 : 0;
+  const supplyDeposits = fmt(v.totalSupply, sup.decimals);
+  const borrowDebt = fmt(v.totalBorrow, bor.decimals);
+  const borrowable = fmt(v.borrowable, bor.decimals);
+  const collateralConfig = {
+    category: 0,
+    label,
+    borrowCollateralFactor: ltv,
+    collateralFactor: lt,
+    borrowFactor: 1,
+    liquidationPenalty: penalty,
+    closeFactor: 1,
+    collateralDisabled: false,
+    debtDisabled: true
+  };
+  const debtConfig = {
+    category: 0,
+    label,
+    borrowCollateralFactor: 0,
+    collateralFactor: 0,
+    borrowFactor: 1,
+    liquidationPenalty: 0,
+    closeFactor: 1,
+    collateralDisabled: true,
+    debtDisabled: false
+  };
+  const common = {
+    totalDebtStable: "0",
+    totalDebtStableUSD: 0,
+    stableBorrowRate: 0,
+    hasStable: false,
+    isActive: true,
+    isFrozen: false,
+    debtCeiling: "0",
+    closeFactor: 1,
+    lockupRatio,
+    rewards: []
+  };
+  const colUid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, sup.address);
+  const debtUid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, bor.address);
+  const collateralLeg = {
+    ...common,
+    marketUid: colUid,
+    name: `Collateral ${supSym}`,
+    poolId: sup.address,
+    underlying: sup.address,
+    asset: supAsset,
+    decimals: sup.decimals,
+    totalDeposits: formatRawUnits(v.totalSupply, sup.decimals),
+    totalDebt: "0",
+    totalLiquidity: supplyDeposits,
+    borrowLiquidity: 0,
+    totalDepositsUSD: supplyDeposits * supPrice,
+    totalDebtUSD: 0,
+    totalLiquidityUSD: supplyDeposits * supPrice,
+    borrowLiquidityUSD: 0,
+    ...layerOf(sup.address),
+    depositRate: bpsToPercent(v.supplyRate),
+    variableBorrowRate: 0,
+    intrinsicYield: intrinsic(supAsset),
+    liquidationBonus: penalty,
+    config: { "0": collateralConfig },
+    collateralActive: true,
+    borrowingEnabled: false,
+    depositsEnabled: true
+  };
+  const debtLeg = {
+    ...common,
+    marketUid: debtUid,
+    name: `Loan ${borSym}`,
+    poolId: bor.address,
+    underlying: bor.address,
+    asset: borAsset,
+    decimals: bor.decimals,
+    totalDeposits: "0",
+    totalDebt: formatRawUnits(v.totalBorrow, bor.decimals),
+    totalLiquidity: borrowable,
+    borrowLiquidity: borrowable,
+    totalDepositsUSD: 0,
+    totalDebtUSD: borrowDebt * borPrice,
+    totalLiquidityUSD: borrowable * borPrice,
+    borrowLiquidityUSD: borrowable * borPrice,
+    ...layerOf(bor.address),
+    depositRate: 0,
+    variableBorrowRate: bpsToPercent(v.borrowRate),
+    intrinsicYield: intrinsic(borAsset),
+    liquidationBonus: 0,
+    originationFee: num(v.borrowFee) / 100,
+    config: { "0": debtConfig },
+    collateralActive: false,
+    borrowingEnabled: true,
+    depositsEnabled: false
+  };
+  const vault = {
+    vaultAddress: v.address,
+    vaultId: v.id,
+    collateralAddress: sup.address,
+    loanAddress: bor.address,
+    collateralDecimals: sup.decimals,
+    loanDecimals: bor.decimals,
+    oracle: v.oracle,
+    ltv,
+    liquidationThreshold: lt,
+    liquidationPenalty: penalty,
+    oraclePriceOperate: jlOracleToFluidRaw(
+      v.oraclePriceOperate,
+      sup.decimals,
+      bor.decimals
+    ),
+    oraclePriceLiquidate: jlOracleToFluidRaw(
+      v.oraclePriceLiquidate,
+      sup.decimals,
+      bor.decimals
+    ),
+    isSmartCol: isJlSmartCol(v.type),
+    isSmartDebt: isJlSmartDebt(v.type),
+    vaultType: v.type <= 1 ? FLUID_VAULT_TYPE_T1 : FLUID_VAULT_TYPE_T1 * Math.min(4, v.type),
+    collateral: {
+      assets: [{ underlying: sup.address, decimals: sup.decimals }],
+      dex: null,
+      perShare: null
+    },
+    loan: {
+      assets: [{ underlying: bor.address, decimals: bor.decimals }],
+      dex: null,
+      perShare: null
+    }
+  };
+  const jupiterLendVault = {
+    market,
+    vaultId: v.id,
+    address: v.address,
+    type: v.type,
+    supplyToken: sup.address,
+    borrowToken: bor.address,
+    supplyDecimals: sup.decimals,
+    borrowDecimals: bor.decimals,
+    collateralFactor: num(v.collateralFactor),
+    liquidationThreshold: num(v.liquidationThreshold),
+    liquidationMaxLimit: num(v.liquidationMaxLimit),
+    withdrawalGap: num(v.withdrawalGap),
+    liquidationPenalty: num(v.liquidationPenalty),
+    borrowFee: num(v.borrowFee),
+    supplyRateMagnifier: num(v.supplyRateMagnifier),
+    borrowRateMagnifier: num(v.borrowRateMagnifier),
+    supplyRateLiquidity: num(v.supplyRateLiquidity),
+    borrowRateLiquidity: num(v.borrowRateLiquidity),
+    minimumBorrowing: v.minimumBorrowing,
+    totalPositions: v.totalPositions,
+    borrowLimit: v.borrowLimit,
+    borrowable: v.borrowable,
+    withdrawLimit: v.withdrawLimit,
+    withdrawable: v.withdrawable,
+    oracle: v.oracle,
+    oraclePrice: v.oraclePrice,
+    oraclePriceOperate: v.oraclePriceOperate,
+    oraclePriceLiquidate: v.oraclePriceLiquidate,
+    oracleSources: v.oracleSources,
+    oracleTimestamp: v.oracleTimestamp,
+    liquiditySupplyData: v.liquiditySupplyData,
+    liquidityBorrowData: v.liquidityBorrowData,
+    topTick: v.topTick,
+    metadata: v.metadata
+  };
+  return {
+    lenderKey,
+    chainId: SOLANA_CHAIN_ID,
+    data: { [colUid]: collateralLeg, [debtUid]: debtLeg },
+    params: { vault, jupiterLendVault }
+  };
 }
 
 // src/lending/public-data/jupiter-lend/fetchPublic.ts
@@ -9717,8 +11146,37 @@ async function fetchJupiterLendPublic(opts = {}) {
         api.vaults(market),
         api.earnTokens(market)
       ]);
-      const layer = deriveLayerTotals(vaults, earn);
       const only = opts.vaultIds?.[market];
+      let chain = [];
+      if (opts.rpc && opts.enumerateOnchain !== false) {
+        try {
+          const next = await readJlNextVaultId(opts.rpc, market);
+          const listed3 = new Set(vaults.map((v) => v.id));
+          const ids = [];
+          for (let id = 1; next && id < next; id++)
+            if (!listed3.has(id) && (!only || only.includes(id))) ids.push(id);
+          if (ids.length) {
+            const tokens = {};
+            for (const v of vaults) {
+              tokens[v.supplyToken.address] ??= v.supplyToken;
+              tokens[v.borrowToken.address] ??= v.borrowToken;
+            }
+            for (const e of earn) tokens[e.assetAddress] ??= e.asset;
+            chain = await readJupiterLendVaultsOnchain(opts.rpc, market, ids, {
+              tokens,
+              tokenList: opts.tokenList
+            });
+          }
+        } catch (e) {
+          console.warn(
+            `[jupiter-lend] on-chain enumeration of ${market} failed, serving the API's vaults only: ${e.message}`
+          );
+        }
+      }
+      const layer = deriveLayerTotals(
+        [...vaults, ...chain.map((c) => c.vault)],
+        earn
+      );
       let flash;
       if (opts.rpc) {
         try {
@@ -9738,13 +11196,39 @@ async function fetchJupiterLendPublic(opts = {}) {
           );
         }
       }
-      for (const v of vaults) {
+      const fromChain = new Map(chain.map((c) => [c.vault.id, c]));
+      for (const v of [...vaults, ...chain.map((c) => c.vault)]) {
         if (only && !only.includes(v.id)) continue;
         const conv = convertJupiterLendVault(market, v, {
           tokenList: opts.tokenList,
           intrinsicYields: opts.intrinsicYields,
           layer
         });
+        const cv = fromChain.get(v.id);
+        const meta = conv.params.jupiterLendVault;
+        meta.source = cv ? "chain" : "api";
+        if (cv) {
+          meta.slot = cv.slot;
+          if (cv.smartCol || cv.smartDebt)
+            meta.smart = {
+              ...cv.smartCol ? {
+                col: {
+                  dex: v.supplyToken.address,
+                  token0: cv.supplyDex?.token0,
+                  token1: cv.supplyDex?.token1
+                }
+              } : {},
+              ...cv.smartDebt ? {
+                debt: {
+                  dex: v.borrowToken.address,
+                  token0: cv.borrowDex?.token0,
+                  token1: cv.borrowDex?.token1
+                }
+              } : {}
+            };
+          const unpriced = [v.supplyToken, v.borrowToken].filter((t) => !(Number(t.price) > 0)).map((t) => t.address);
+          if (unpriced.length) meta.unpriced = unpriced;
+        }
         if (flash)
           conv.params.jupiterLendVault.flashloan = {
             feeBps: flash.feeBps,
@@ -10208,7 +11692,7 @@ var LS_NO_ACCOUNT = "11111111111111111111111111111111";
 var LS_U64_MAX = "18446744073709551615";
 var isUncapped = (v) => v === void 0 || v === null || String(v) === LS_U64_MAX;
 var capOrUndefined = (v) => isUncapped(v) ? void 0 : String(v);
-var SECONDS_PER_YEAR = 31536e3;
+var SECONDS_PER_YEAR2 = 31536e3;
 var LS_TENORS = [
   { id: "1d", duration: { duration: 1, durationType: 0 }, days: 1 },
   { id: "1w", duration: { duration: 1, durationType: 1 }, days: 7 },
@@ -10364,6 +11848,8 @@ async function buildLoopscaleRoster(vaults, loops, opts = {}) {
         strategy: s.address,
         name: v.vaultMetadata?.name ?? v.vault.address,
         curator: v.vaultMetadata?.managerName ?? "",
+        manager: v.vault.manager,
+        managerImage: v.vaultMetadata?.managerImage ?? void 0,
         interestFee: Number(s.interestFee),
         originationFee: Number(s.originationFee),
         originationsEnabled: s.originationsEnabled,
@@ -10413,20 +11899,20 @@ async function buildLoopscaleRoster(vaults, loops, opts = {}) {
   const unresolved = [];
   if (toProbe.length && opts.rpc) {
     const mints = await getMints(opts.rpc, toProbe);
-    const dec = /* @__PURE__ */ new Map();
-    mints.forEach((m, i) => m && dec.set(toProbe[i], m.decimals));
+    const dec2 = /* @__PURE__ */ new Map();
+    mints.forEach((m, i) => m && dec2.set(toProbe[i], m.decimals));
     for (const pair of byKey.values()) {
       const c = pair.collateralIdentifier;
-      if (pair.assetType === -1 && dec.has(c)) {
+      if (pair.assetType === -1 && dec2.has(c)) {
         pair.assetType = 0;
         pair.collateralMint = c;
       }
       if (pair.collateralMint && pair.collateralDecimals === void 0)
-        pair.collateralDecimals = dec.get(pair.collateralMint);
+        pair.collateralDecimals = dec2.get(pair.collateralMint);
       if (pair.principalDecimals === void 0)
-        pair.principalDecimals = dec.get(pair.principalMint);
+        pair.principalDecimals = dec2.get(pair.principalMint);
     }
-    for (const c of unknown) if (!dec.has(c)) unresolved.push(c);
+    for (const c of unknown) if (!dec2.has(c)) unresolved.push(c);
   } else unresolved.push(...unknown);
   const pairs = [...byKey.values()].filter(
     (p) => (p.assetType === 0 || opts.includeUnresolvedCollateral) && (want ? want.has(key2(p.principalMint, p.collateralIdentifier)) : true)
@@ -10861,9 +12347,9 @@ import { createSvmRpc } from "@1delta/svm-kit";
 
 // src/lending/public-data/loopscale/accounts.ts
 import {
-  decodeIdlAccount as decodeIdlAccount3,
+  decodeIdlAccount as decodeIdlAccount4,
   encodeBase58 as encodeBase583,
-  fromBase64 as fromBase643
+  fromBase64 as fromBase644
 } from "@1delta/svm-kit";
 
 // src/lending/public-data/loopscale/idl/loopscale.json
@@ -17847,7 +19333,7 @@ var podDecimalToNumber = (p) => Number(podToBigInt(p)) / 1e18;
 var podBool = (p) => bytesOf(p)[0] !== 0;
 var raw = (v) => v;
 function decodeLoopscaleLoan(data) {
-  const r = raw(decodeIdlAccount3(LOOPSCALE_IDL, "Loan", data));
+  const r = raw(decodeIdlAccount4(LOOPSCALE_IDL, "Loan", data));
   const zero = encodeBase583(new Uint8Array(32));
   const ledgers = r.ledgers.map(
     (l) => ({
@@ -17892,7 +19378,7 @@ function decodeLoopscaleLoan(data) {
   };
 }
 function decodeLoopscaleStrategy(data) {
-  const r = raw(decodeIdlAccount3(LOOPSCALE_IDL, "Strategy", data));
+  const r = raw(decodeIdlAccount4(LOOPSCALE_IDL, "Strategy", data));
   return {
     version: r.version,
     nonce: r.nonce,
@@ -17929,12 +19415,12 @@ async function readLoopscaleLoans(rpc, loanAddresses) {
   return {
     slot,
     loans: accounts.map(
-      (a) => a && a.owner === LOOPSCALE_PROGRAM_ID ? decodeLoopscaleLoan(fromBase643(a.data[0])) : null
+      (a) => a && a.owner === LOOPSCALE_PROGRAM_ID ? decodeLoopscaleLoan(fromBase644(a.data[0])) : null
     )
   };
 }
 function decodeLoopscaleMarketInformation(data) {
-  const r = raw(decodeIdlAccount3(LOOPSCALE_IDL, "MarketInformation", data));
+  const r = raw(decodeIdlAccount4(LOOPSCALE_IDL, "MarketInformation", data));
   const zero = encodeBase583(new Uint8Array(32));
   const caps = (c) => ({
     max1hr: podToBigInt(c.max_1hr).toString(),
@@ -17984,7 +19470,7 @@ async function readLoopscaleMarketInformation(rpc, addresses) {
     try {
       out.set(
         unique[i],
-        decodeLoopscaleMarketInformation(fromBase643(a.data[0]))
+        decodeLoopscaleMarketInformation(fromBase644(a.data[0]))
       );
     } catch (e) {
       console.warn(
@@ -18295,18 +19781,18 @@ function tenorsToQuote(pair, all) {
   return out;
 }
 function deriveLoopscalePrices(vaults, loops, pairs, tokenList, loanBook) {
-  const dec = /* @__PURE__ */ new Map();
-  for (const [m, t] of Object.entries(tokenList ?? {})) dec.set(m, t.decimals);
+  const dec2 = /* @__PURE__ */ new Map();
+  for (const [m, t] of Object.entries(tokenList ?? {})) dec2.set(m, t.decimals);
   for (const p of pairs) {
     if (p.principalDecimals !== void 0)
-      dec.set(p.principalMint, p.principalDecimals);
+      dec2.set(p.principalMint, p.principalDecimals);
     if (p.collateralMint && p.collateralDecimals !== void 0)
-      dec.set(p.collateralMint, p.collateralDecimals);
+      dec2.set(p.collateralMint, p.collateralDecimals);
   }
   const out = {};
   const best = /* @__PURE__ */ new Map();
   const offer = (mint, usd, raw2) => {
-    const d2 = dec.get(mint);
+    const d2 = dec2.get(mint);
     if (d2 === void 0 || !usd || !(raw2 > 0)) return;
     if ((best.get(mint) ?? 0) < usd) {
       best.set(mint, usd);
@@ -18337,7 +19823,7 @@ function deriveLoopscalePrices(vaults, loops, pairs, tokenList, loanBook) {
 }
 
 // src/prices/pythPush.ts
-import { fromBase64 as fromBase644 } from "@1delta/svm-kit";
+import { fromBase64 as fromBase645 } from "@1delta/svm-kit";
 var PYTH_RECEIVER_PROGRAM = "rec2HHDDnjLfj4kE7VyEtFA1HPGQLK33259532cRyHp";
 var PYTH_PRICE_UPDATE_V2_DISCRIMINATOR = [
   34,
@@ -18350,7 +19836,7 @@ var PYTH_PRICE_UPDATE_V2_DISCRIMINATOR = [
   205
 ];
 function decodePythPriceUpdate(data) {
-  const b = typeof data === "string" ? fromBase644(data) : data;
+  const b = typeof data === "string" ? fromBase645(data) : data;
   for (let i = 0; i < 8; i++)
     if (b[i] !== PYTH_PRICE_UPDATE_V2_DISCRIMINATOR[i])
       throw new Error("pyth: account is not a PriceUpdateV2");
@@ -18485,10 +19971,10 @@ function createP0Api(opts = {}) {
 
 // src/lending/public-data/project0/accounts.ts
 import {
-  decodeBase58 as decodeBase583,
-  decodeIdlAccount as decodeIdlAccount4,
-  findProgramAddress as findProgramAddress3,
-  fromBase64 as fromBase645
+  decodeBase58 as decodeBase584,
+  decodeIdlAccount as decodeIdlAccount5,
+  findProgramAddress as findProgramAddress4,
+  fromBase64 as fromBase646
 } from "@1delta/svm-kit";
 
 // src/lending/public-data/project0/idl/marginfi.json
@@ -33353,34 +34839,34 @@ function decimalStringToI80F48(s) {
   for (let i = 0; i < 16; i++) out[i] = Number(u >> BigInt(8 * i) & 0xffn);
   return out;
 }
-var utf83 = (s) => new TextEncoder().encode(s);
-var pk3 = (address) => {
-  const b = decodeBase583(address);
+var utf84 = (s) => new TextEncoder().encode(s);
+var pk4 = (address) => {
+  const b = decodeBase584(address);
   if (!b || b.length !== 32)
     throw new Error(`project0: not a 32-byte pubkey: ${address}`);
   return b;
 };
-var u16le = (n) => {
+var u16le2 = (n) => {
   if (!Number.isInteger(n) || n < 0 || n > 65535)
     throw new Error(`project0: u16 out of range: ${n}`);
   return new Uint8Array([n & 255, n >> 8]);
 };
-var p0LiquidityVaultAuthority = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress3(
-  [utf83(P0_SEEDS.liquidityVaultAuthority), pk3(bank)],
+var p0LiquidityVaultAuthority = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress4(
+  [utf84(P0_SEEDS.liquidityVaultAuthority), pk4(bank)],
   programId
 )).address;
-var p0LiquidityVault = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress3(
-  [utf83(P0_SEEDS.liquidityVault), pk3(bank)],
+var p0LiquidityVault = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress4(
+  [utf84(P0_SEEDS.liquidityVault), pk4(bank)],
   programId
 )).address;
-var p0FeeState = async (programId = P0_PROGRAM_ID) => (await findProgramAddress3([utf83(P0_SEEDS.feeState)], programId)).address;
-var p0MarginfiAccountPda = async (authority, accountIndex = 0, opts = {}) => (await findProgramAddress3(
+var p0FeeState = async (programId = P0_PROGRAM_ID) => (await findProgramAddress4([utf84(P0_SEEDS.feeState)], programId)).address;
+var p0MarginfiAccountPda = async (authority, accountIndex = 0, opts = {}) => (await findProgramAddress4(
   [
-    utf83(P0_SEEDS.marginfiAccount),
-    pk3(opts.group ?? P0_MAIN_GROUP),
-    pk3(authority),
-    u16le(accountIndex),
-    u16le(opts.thirdPartyId ?? 0)
+    utf84(P0_SEEDS.marginfiAccount),
+    pk4(opts.group ?? P0_MAIN_GROUP),
+    pk4(authority),
+    u16le2(accountIndex),
+    u16le2(opts.thirdPartyId ?? 0)
   ],
   opts.programId ?? P0_PROGRAM_ID
 )).address;
@@ -33464,8 +34950,8 @@ var bankConfig = (c) => ({
   cbEmaAlphaBps: c.cb_ema_alpha_bps
 });
 function decodeP0Bank(address, data, tokenSymbol) {
-  const bytes = typeof data === "string" ? fromBase645(data) : data;
-  const r = decodeIdlAccount4(P0_IDL, "Bank", bytes);
+  const bytes2 = typeof data === "string" ? fromBase646(data) : data;
+  const r = decodeIdlAccount5(P0_IDL, "Bank", bytes2);
   const entries = r.emode.emode_config.entries.filter((e) => e.collateral_bank_emode_tag !== 0).map((e) => ({
     collateralBankEmodeTag: e.collateral_bank_emode_tag,
     flags: e.flags,
@@ -33690,8 +35176,8 @@ var u32ToBasis = (v) => v / 4294967295 * 100;
 var P0_PAUSE_DURATION_SECONDS = 6 * 60 * 60;
 var p0GroupPausedAt = (g, now) => !!g?.panic.pausedFlag && (now < g.panic.pauseStartTimestamp || now - g.panic.pauseStartTimestamp < P0_PAUSE_DURATION_SECONDS);
 function decodeP0Group(address, data) {
-  const bytes = typeof data === "string" ? fromBase645(data) : data;
-  const r = decodeIdlAccount4(P0_IDL, "MarginfiGroup", bytes);
+  const bytes2 = typeof data === "string" ? fromBase646(data) : data;
+  const r = decodeIdlAccount5(P0_IDL, "MarginfiGroup", bytes2);
   return {
     address,
     admin: r.admin,
@@ -33724,11 +35210,11 @@ function decodeP0Group(address, data) {
   };
 }
 function decodeP0MarginfiAccount(address, data) {
-  const bytes = typeof data === "string" ? fromBase645(data) : data;
-  const r = decodeIdlAccount4(
+  const bytes2 = typeof data === "string" ? fromBase646(data) : data;
+  const r = decodeIdlAccount5(
     P0_IDL,
     "MarginfiAccount",
-    bytes
+    bytes2
   );
   const h = r.health_cache;
   return {
@@ -33780,10 +35266,10 @@ var P0_GROUP_SIZE = 9256;
 var P0_ACCOUNT_GROUP_OFFSET = 8;
 var P0_ACCOUNT_AUTHORITY_OFFSET = 8 + 32;
 var P0_BANK_GROUP_OFFSET = 8 + 32 + 1;
-var p0BankMetadataPda = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress3([utf83("metadata"), pk3(bank)], programId)).address;
+var p0BankMetadataPda = async (bank, programId = P0_PROGRAM_ID) => (await findProgramAddress4([utf84("metadata"), pk4(bank)], programId)).address;
 function decodeP0BankMetadata(data) {
-  const bytes = typeof data === "string" ? fromBase645(data) : data;
-  const r = decodeIdlAccount4(P0_IDL, "BankMetadata", bytes);
+  const bytes2 = typeof data === "string" ? fromBase646(data) : data;
+  const r = decodeIdlAccount5(P0_IDL, "BankMetadata", bytes2);
   const td = new TextDecoder();
   const ticker = td.decode(r.ticker.subarray(0, r.end_ticker_byte)).trim();
   const description = td.decode(r.description.subarray(0, r.end_description_byte)).trim();
@@ -33933,7 +35419,7 @@ function p0CurveKnots(c) {
 }
 
 // src/vaults/lst/stakePool.ts
-import { BorshReader, encodeBase58 as encodeBase584, fromBase64 as fromBase646 } from "@1delta/svm-kit";
+import { BorshReader, encodeBase58 as encodeBase584, fromBase64 as fromBase647 } from "@1delta/svm-kit";
 var SPL_STAKE_POOL_PROGRAM = "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy";
 var OFFSET_RESERVE_STAKE = 130;
 var OFFSET_POOL_MINT = 162;
@@ -34009,7 +35495,7 @@ async function readStakePools(rpc, stakePools, opts = {}) {
   const pools = accounts.map((a) => {
     if (!a || a.owner !== program) return null;
     try {
-      return decodeStakePool(fromBase646(a.data[0]));
+      return decodeStakePool(fromBase647(a.data[0]));
     } catch {
       return null;
     }
@@ -34061,7 +35547,127 @@ async function readEpochClock(rpc) {
 }
 
 // src/lending/public-data/project0/prices.ts
-import { fromBase64 as fromBase647 } from "@1delta/svm-kit";
+import { fromBase64 as fromBase649 } from "@1delta/svm-kit";
+
+// src/prices/oracleAccounts.ts
+import { fromBase64 as fromBase648 } from "@1delta/svm-kit";
+var PYTH_PRICE_UPDATE_OWNERS = /* @__PURE__ */ new Set([
+  "rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ",
+  "rec2HHDDnjLfj4kE7VyEtFA1HPGQLK33259532cRyHp"
+]);
+var PYTH_LEGACY_PROGRAM = "FsJ3A3u2vn5cTVofAjvy6y5kwABJAqYWpe4975bi2epH";
+var SWITCHBOARD_ON_DEMAND_PROGRAM = "SBondMDrcV3K4kxZR1HNVT7osZxAHVHgYXL5Ze1oMUv";
+var SWITCHBOARD_V2_PROGRAM = "SW1TCH7qEPTdLsDHRgPuMQjbQxKdH2aBStViMFnt64f";
+var SCOPE_PROGRAM = "HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ";
+var MARINADE_PROGRAM = "MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD";
+var bytes = (data) => typeof data === "string" ? fromBase648(data) : data;
+var view = (b) => new DataView(b.buffer, b.byteOffset, b.byteLength);
+var i128 = (b, o) => {
+  const dv = view(b);
+  const lo = dv.getBigUint64(o, true);
+  const hi = dv.getBigInt64(o + 8, true);
+  return (hi << 64n) + lo;
+};
+var disc = (b, d2) => d2.every((x, i) => b[i] === x);
+var SB_PULL_FEED_DISCRIMINATOR = [196, 27, 108, 196, 10, 215, 219, 40];
+var SB_V2_AGGREGATOR_DISCRIMINATOR = [
+  217,
+  230,
+  65,
+  101,
+  201,
+  162,
+  27,
+  125
+];
+var PYTH_LEGACY_MAGIC = 2712847316;
+function decodeSwitchboardPullFeed(data) {
+  const b = bytes(data);
+  if (!disc(b, SB_PULL_FEED_DISCRIMINATOR) || b.length < 2392)
+    throw new Error("switchboard: account is not a PullFeedAccountData");
+  const dv = view(b);
+  const value = i128(b, 2264);
+  return {
+    kind: "switchboard-on-demand",
+    price: Number(value) / 1e18,
+    updatedAt: Number(dv.getBigInt64(2216, true)),
+    slot: Number(dv.getBigUint64(2368, true)),
+    name: new TextDecoder().decode(b.subarray(2180, 2212)).replace(/\0+$/, "")
+  };
+}
+function decodeSwitchboardV2Aggregator(data) {
+  const b = bytes(data);
+  if (!disc(b, SB_V2_AGGREGATOR_DISCRIMINATOR) || b.length < 386)
+    throw new Error("switchboard: account is not an AggregatorAccountData");
+  const dv = view(b);
+  const mantissa = i128(b, 366);
+  const scale = dv.getUint32(382, true);
+  return {
+    kind: "switchboard-v2",
+    price: Number(mantissa) / 10 ** scale,
+    updatedAt: Number(dv.getBigInt64(358, true)),
+    slot: Number(dv.getBigUint64(350, true)),
+    name: new TextDecoder().decode(b.subarray(8, 40)).replace(/\0+$/, "")
+  };
+}
+function decodePythLegacyPrice(data) {
+  const b = bytes(data);
+  const dv = view(b);
+  if (b.length < 240 || dv.getUint32(0, true) !== PYTH_LEGACY_MAGIC)
+    throw new Error("pyth: account is not a legacy price account");
+  if (dv.getUint32(8, true) !== 3)
+    throw new Error("pyth: legacy account is not a PRICE account");
+  const expo = dv.getInt32(20, true);
+  return {
+    kind: "pyth-legacy",
+    price: Number(dv.getBigInt64(208, true)) * 10 ** expo,
+    updatedAt: Number(dv.getBigInt64(96, true)),
+    slot: Number(dv.getBigUint64(232, true)),
+    status: dv.getUint32(224, true)
+  };
+}
+var SCOPE_PRICES_LEN = 512;
+function decodeScopePrice(data, index) {
+  const b = bytes(data);
+  if (!Number.isInteger(index) || index < 0 || index >= SCOPE_PRICES_LEN)
+    throw new Error(`scope: entry index ${index} out of range`);
+  const o = 8 + 32 + index * 56;
+  if (b.length < o + 32) throw new Error("scope: account too short");
+  const dv = view(b);
+  const value = dv.getBigUint64(o, true);
+  const exp = Number(dv.getBigUint64(o + 8, true));
+  return {
+    kind: "scope",
+    price: Number(value) / 10 ** exp,
+    updatedAt: Number(dv.getBigUint64(o + 24, true)),
+    slot: Number(dv.getBigUint64(o + 16, true))
+  };
+}
+function decodeMarinadeMsolPrice(data) {
+  const b = bytes(data);
+  if (b.length < 520) throw new Error("marinade: account too short");
+  return Number(view(b).getBigUint64(512, true)) / 2 ** 32;
+}
+function decodeOracleFeed(account) {
+  const b = bytes(account.data);
+  if (PYTH_PRICE_UPDATE_OWNERS.has(account.owner) && disc(b, PYTH_PRICE_UPDATE_V2_DISCRIMINATOR)) {
+    const p = decodePythPriceUpdate(b);
+    return {
+      kind: "pyth-push",
+      price: p.priceUsd,
+      updatedAt: p.publishTime,
+      slot: p.postedSlot
+    };
+  }
+  if (account.owner === SWITCHBOARD_ON_DEMAND_PROGRAM)
+    return decodeSwitchboardPullFeed(b);
+  if (account.owner === SWITCHBOARD_V2_PROGRAM)
+    return decodeSwitchboardV2Aggregator(b);
+  if (account.owner === PYTH_LEGACY_PROGRAM) return decodePythLegacyPrice(b);
+  return void 0;
+}
+
+// src/lending/public-data/project0/prices.ts
 var P0_PYTH_PUSH_SETUPS = /* @__PURE__ */ new Set([
   "PythPushOracle",
   "StakedWithPythPush",
@@ -34099,6 +35705,7 @@ var stakePoolKeyOf = (b) => {
       return void 0;
   }
 };
+var marinadeKeyOf = (b) => b.config.oracleSetup === "PythMSOL" ? b.config.oracleKeys[1] : void 0;
 var isP0FixedSetup = (setup) => setup.startsWith("Fixed");
 var P0_STAKE_POOL_PROGRAMS = /* @__PURE__ */ new Set([
   SPL_STAKE_POOL_PROGRAM,
@@ -34109,6 +35716,8 @@ var DRIFT_SCALED_BALANCE_DECIMALS = 9;
 async function resolveP0Prices(rpc, banks, opts = {}) {
   const pythKeys = /* @__PURE__ */ new Set();
   const poolKeys = /* @__PURE__ */ new Set();
+  const marinadeKeys = /* @__PURE__ */ new Set();
+  const scopeKeys = /* @__PURE__ */ new Set();
   if (!opts.cacheOnly && rpc)
     for (const b of banks) {
       if (P0_PYTH_PUSH_SETUPS.has(b.config.oracleSetup)) {
@@ -34117,12 +35726,20 @@ async function resolveP0Prices(rpc, banks, opts = {}) {
       }
       const pool = stakePoolKeyOf(b);
       if (!isNullKey(pool)) poolKeys.add(pool);
+      const msol = marinadeKeyOf(b);
+      if (!isNullKey(msol)) marinadeKeys.add(msol);
+      if (b.config.oracleSetup === "Scope") {
+        const k = b.config.oracleKeys[0];
+        if (!isNullKey(k)) scopeKeys.add(k);
+      }
     }
   const pyth = {};
   const poolRate = {};
+  const msolRate = {};
+  const scopeData = {};
   let slot = 0;
-  if (pythKeys.size || poolKeys.size) {
-    const keys = [...pythKeys, ...poolKeys];
+  if (pythKeys.size || poolKeys.size || marinadeKeys.size || scopeKeys.size) {
+    const keys = [...pythKeys, ...poolKeys, ...marinadeKeys, ...scopeKeys];
     const res = await rpc.readAccounts(keys, { encoding: "base64" });
     slot = res.slot;
     res.accounts.forEach((a, i) => {
@@ -34132,8 +35749,15 @@ async function resolveP0Prices(rpc, banks, opts = {}) {
         if (pythKeys.has(key2)) {
           if (a.owner === PYTH_RECEIVER_PROGRAM)
             pyth[key2] = decodePythPriceUpdate(a.data[0]);
+        } else if (marinadeKeys.has(key2)) {
+          if (a.owner === MARINADE_PROGRAM) {
+            const r = decodeMarinadeMsolPrice(a.data[0]);
+            if (r > 0) msolRate[key2] = r;
+          }
+        } else if (scopeKeys.has(key2)) {
+          if (a.owner === SCOPE_PROGRAM) scopeData[key2] = fromBase649(a.data[0]);
         } else if (P0_STAKE_POOL_PROGRAMS.has(a.owner)) {
-          const p = decodeStakePool(fromBase647(a.data[0]));
+          const p = decodeStakePool(fromBase649(a.data[0]));
           if (p.poolTokenSupply > 0n)
             poolRate[key2] = Number(p.totalLamports) / Number(p.poolTokenSupply);
         }
@@ -34160,8 +35784,15 @@ async function resolveP0Prices(rpc, banks, opts = {}) {
     }
     const feed = b.config.oracleKeys[0];
     const live = feed && !isNullKey(feed) ? pyth[feed] : void 0;
-    const pool = stakePoolKeyOf(b);
-    const liveRate = pool ? poolRate[pool] : void 0;
+    const pool = stakePoolKeyOf(b) ?? marinadeKeyOf(b);
+    const liveRate = pool ? poolRate[pool] ?? msolRate[pool] : void 0;
+    let scope;
+    if (setup === "Scope" && feed && scopeData[feed])
+      try {
+        scope = decodeScopePrice(scopeData[feed], b.config.scopeEntryIndex);
+      } catch (e) {
+        console.warn(`[project0] scope ${feed}: ${e.message}`);
+      }
     let liveMult = 1;
     let liveMultNote = "";
     if (P0_CACHED_PRICE_MULTIPLIER_SETUPS.has(setup)) {
@@ -34169,7 +35800,7 @@ async function resolveP0Prices(rpc, banks, opts = {}) {
       liveMultNote = `cached SVSP rate ${cacheMult?.toFixed(6)} as of ${cacheTs}`;
     } else if (P0_ADJUSTED_CACHE_SETUPS.has(setup)) {
       liveMult = liveRate ?? null;
-      liveMultNote = liveRate ? `SPL stake pool ${pool} rate ${liveRate.toFixed(6)}` : "";
+      liveMultNote = liveRate ? `${msolRate[pool] ? "Marinade state" : "SPL stake pool"} ${pool} rate ${liveRate.toFixed(6)}` : "";
     }
     let out;
     if (isP0FixedSetup(setup)) {
@@ -34186,6 +35817,15 @@ async function resolveP0Prices(rpc, banks, opts = {}) {
         multiplier: 1,
         description: `admin-set fixed price (${setup})`
       };
+    } else if (scope && scope.price > 0) {
+      out = {
+        priceUsd: scope.price,
+        source: "scope",
+        updatedAt: scope.updatedAt || void 0,
+        multiplier: 1,
+        feed,
+        description: `Scope ${feed} entry ${b.config.scopeEntryIndex} (${setup})`
+      };
     } else if (live && liveMult !== null && liveMult > 0) {
       out = {
         priceUsd: live.priceUsd * liveMult,
@@ -35103,9 +36743,9 @@ function liquidityRatio(liquidity, totalAssets) {
 // src/vaults/jupiter-lend/index.ts
 function convertJupiterLendEarnToken(market, t, tokenList) {
   const price = num(t.asset.price);
-  const dec = t.asset.decimals;
-  const totalAssetsFormatted = Number(t.totalAssets) / 10 ** dec;
-  const liquidityFormatted = Number(t.liquiditySupplyData.withdrawable) / 10 ** dec;
+  const dec2 = t.asset.decimals;
+  const totalAssetsFormatted = Number(t.totalAssets) / 10 ** dec2;
+  const liquidityFormatted = Number(t.liquiditySupplyData.withdrawable) / 10 ** dec2;
   const sharePrice = Number(t.convertToAssets) / 10 ** t.decimals;
   const supplyRate = bpsToPercent(t.supplyRate);
   const rewardsRate = bpsToPercent(t.rewardsRate);
@@ -35114,7 +36754,7 @@ function convertJupiterLendEarnToken(market, t, tokenList) {
     address: t.assetAddress,
     symbol: t.asset.uiSymbol,
     name: t.asset.name,
-    decimals: dec,
+    decimals: dec2,
     ...t.asset.logoUrl ? { logoURI: t.asset.logoUrl } : {}
   };
   return {
@@ -35129,7 +36769,7 @@ function convertJupiterLendEarnToken(market, t, tokenList) {
     displayName: `Jupiter Lend ${t.asset.uiSymbol}`,
     curatorName: "Jupiter",
     decimals: t.decimals,
-    assetDecimals: dec,
+    assetDecimals: dec2,
     totalAssets: t.totalAssets,
     totalSupply: t.totalSupply,
     convertToShares: t.convertToShares,
@@ -35388,11 +37028,11 @@ async function fetchExponentPtMarkets(opts = {}) {
 
 // src/vaults/solstice/accounts.ts
 import {
-  decodeBase58 as decodeBase584,
-  decodeIdlAccount as decodeIdlAccount5,
+  decodeBase58 as decodeBase585,
+  decodeIdlAccount as decodeIdlAccount6,
   encodeBase58 as encodeBase585,
-  findProgramAddress as findProgramAddress4,
-  fromBase64 as fromBase648
+  findProgramAddress as findProgramAddress5,
+  fromBase64 as fromBase6410
 } from "@1delta/svm-kit";
 
 // src/vaults/solstice/idl/yield_strategy.json
@@ -46062,14 +47702,14 @@ var SOLSTICE_MINTS = {
 var SOLSTICE_STRATEGIES = ["STRC-USX"];
 var SOLSTICE_DECIMALS = 6;
 var SOLSTICE_PRICE_DECIMALS = 6;
-var utf84 = (s) => new TextEncoder().encode(s);
-var pk4 = (address) => {
-  const b = decodeBase584(address);
+var utf85 = (s) => new TextEncoder().encode(s);
+var pk5 = (address) => {
+  const b = decodeBase585(address);
   if (!b || b.length !== 32)
     throw new Error(`solstice: not a 32-byte pubkey: ${address}`);
   return b;
 };
-var pda = async (seeds, programId) => (await findProgramAddress4(seeds, programId)).address;
+var pda = async (seeds, programId) => (await findProgramAddress5(seeds, programId)).address;
 async function yieldVaultPdas(programId = SOLSTICE_PROGRAMS.yieldVault) {
   const [controller, yieldPool, vestingSchedule, shareMint, assetVault] = await Promise.all(
     [
@@ -46078,19 +47718,19 @@ async function yieldVaultPdas(programId = SOLSTICE_PROGRAMS.yieldVault) {
       "VESTING_SCHEDULE",
       "SHARE_MINT",
       "ASSET_VAULT"
-    ].map((s) => pda([utf84(s)], programId))
+    ].map((s) => pda([utf85(s)], programId))
   );
   return { controller, yieldPool, vestingSchedule, shareMint, assetVault };
 }
 async function yieldVaultCooldownPdas(user, programId = SOLSTICE_PROGRAMS.yieldVault) {
   const [escrow, escrowVault] = await Promise.all([
-    pda([utf84("COOLDOWN_ESCROW"), pk4(user)], programId),
-    pda([utf84("COOLDOWN_ESCROW_VAULT"), pk4(user)], programId)
+    pda([utf85("COOLDOWN_ESCROW"), pk5(user)], programId),
+    pda([utf85("COOLDOWN_ESCROW_VAULT"), pk5(user)], programId)
   ]);
   return { escrow, escrowVault };
 }
 async function strategyPdas(name, programId = SOLSTICE_PROGRAMS.yieldStrategy) {
-  const n = utf84(name);
+  const n = utf85(name);
   if (n.length < 1 || n.length > 32)
     throw new Error(`solstice: strategy name must be 1..=32 bytes: ${name}`);
   const [
@@ -46102,13 +47742,13 @@ async function strategyPdas(name, programId = SOLSTICE_PROGRAMS.yieldStrategy) {
     assetVault,
     feeVault
   ] = await Promise.all([
-    pda([utf84("CONTROLLER")], programId),
-    pda([utf84("STRATEGY"), n], programId),
-    pda([utf84("ACCOUNTING"), n], programId),
-    pda([utf84("JUNIOR_MINT"), n], programId),
-    pda([utf84("SENIOR_MINT"), n], programId),
-    pda([utf84("ASSET_VAULT"), n], programId),
-    pda([utf84("FEE_VAULT"), n], programId)
+    pda([utf85("CONTROLLER")], programId),
+    pda([utf85("STRATEGY"), n], programId),
+    pda([utf85("ACCOUNTING"), n], programId),
+    pda([utf85("JUNIOR_MINT"), n], programId),
+    pda([utf85("SENIOR_MINT"), n], programId),
+    pda([utf85("ASSET_VAULT"), n], programId),
+    pda([utf85("FEE_VAULT"), n], programId)
   ]);
   return {
     name,
@@ -46123,10 +47763,10 @@ async function strategyPdas(name, programId = SOLSTICE_PROGRAMS.yieldStrategy) {
 }
 async function settlementBatchPdas(strategyName, batchName, programId = SOLSTICE_PROGRAMS.yieldStrategy) {
   const seeds = (tag) => [
-    utf84(tag),
-    utf84(strategyName),
+    utf85(tag),
+    utf85(strategyName),
     Uint8Array.of(0),
-    utf84(batchName)
+    utf85(batchName)
   ];
   const [batch, shareVault, assetVault] = await Promise.all([
     pda(seeds("SETTLEMENT_BATCH"), programId),
@@ -46135,34 +47775,34 @@ async function settlementBatchPdas(strategyName, batchName, programId = SOLSTICE
   ]);
   return { batch, shareVault, assetVault };
 }
-var juniorUnlockSharePda = (batch, user, programId = SOLSTICE_PROGRAMS.yieldStrategy) => pda([utf84("JUNIOR_UNLOCK_SHARE"), pk4(batch), pk4(user)], programId);
+var juniorUnlockSharePda = (batch, user, programId = SOLSTICE_PROGRAMS.yieldStrategy) => pda([utf85("JUNIOR_UNLOCK_SHARE"), pk5(batch), pk5(user)], programId);
 async function seniorCooldownPdas(strategyName, user, programId = SOLSTICE_PROGRAMS.yieldStrategy) {
   const [cooldown, cooldownVault] = await Promise.all([
     pda(
-      [utf84("SENIOR_UNLOCK_COOLDOWN"), utf84(strategyName), pk4(user)],
+      [utf85("SENIOR_UNLOCK_COOLDOWN"), utf85(strategyName), pk5(user)],
       programId
     ),
     pda(
-      [utf84("SENIOR_COOLDOWN_VAULT"), utf84(strategyName), pk4(user)],
+      [utf85("SENIOR_COOLDOWN_VAULT"), utf85(strategyName), pk5(user)],
       programId
     )
   ]);
   return { cooldown, cooldownVault };
 }
-var oracleCanonicalPda = (feedId, programId = SOLSTICE_PROGRAMS.oracle) => pda([utf84("CANONICAL"), utf84(feedId)], programId);
+var oracleCanonicalPda = (feedId, programId = SOLSTICE_PROGRAMS.oracle) => pda([utf85("CANONICAL"), utf85(feedId)], programId);
 var strategyNameOf = (raw2) => new TextDecoder().decode(raw2).replace(/\0+$/, "");
 var YV = SOLSTICE_YIELD_VAULT_IDL;
 var YS = SOLSTICE_YIELD_STRATEGY_IDL;
-var decodeController = (d2) => decodeIdlAccount5(YV, "Controller", d2);
-var decodeYieldPool = (d2) => decodeIdlAccount5(YV, "YieldPool", d2);
-var decodeVestingSchedule = (d2) => decodeIdlAccount5(YV, "VestingSchedule", d2);
-var decodeCooldownEscrow = (d2) => decodeIdlAccount5(YV, "CooldownEscrow", d2);
-var decodeStrategyController = (d2) => decodeIdlAccount5(YS, "Controller", d2);
-var decodeStrategy = (d2) => decodeIdlAccount5(YS, "Strategy", d2);
-var decodeAccountingState = (d2) => decodeIdlAccount5(YS, "AccountingState", d2);
-var decodeSettlementBatch = (d2) => decodeIdlAccount5(YS, "SettlementBatch", d2);
-var decodeJuniorUnlockShare = (d2) => decodeIdlAccount5(YS, "JuniorUnlockShare", d2);
-var decodeSeniorUnlockCooldown = (d2) => decodeIdlAccount5(YS, "SeniorUnlockCooldown", d2);
+var decodeController = (d2) => decodeIdlAccount6(YV, "Controller", d2);
+var decodeYieldPool = (d2) => decodeIdlAccount6(YV, "YieldPool", d2);
+var decodeVestingSchedule = (d2) => decodeIdlAccount6(YV, "VestingSchedule", d2);
+var decodeCooldownEscrow = (d2) => decodeIdlAccount6(YV, "CooldownEscrow", d2);
+var decodeStrategyController = (d2) => decodeIdlAccount6(YS, "Controller", d2);
+var decodeStrategy = (d2) => decodeIdlAccount6(YS, "Strategy", d2);
+var decodeAccountingState = (d2) => decodeIdlAccount6(YS, "AccountingState", d2);
+var decodeSettlementBatch = (d2) => decodeIdlAccount6(YS, "SettlementBatch", d2);
+var decodeJuniorUnlockShare = (d2) => decodeIdlAccount6(YS, "JuniorUnlockShare", d2);
+var decodeSeniorUnlockCooldown = (d2) => decodeIdlAccount6(YS, "SeniorUnlockCooldown", d2);
 function accountDiscriminator(idl, name) {
   const a = idl.accounts.find((x) => x.name === name);
   if (!a) throw new Error(`idl ${idl.metadata?.name}: no account ${name}`);
@@ -46209,7 +47849,7 @@ function tokenAmount(data) {
 }
 var need = (a, what) => {
   if (!a) throw new Error(`solstice: ${what} account is missing`);
-  return fromBase648(a.data[0]);
+  return fromBase6410(a.data[0]);
 };
 async function readSolsticeChainState(rpc, opts = {}) {
   const programs = { ...SOLSTICE_PROGRAMS, ...opts.programs };
@@ -46274,7 +47914,7 @@ async function readSolsticeChainState(rpc, opts = {}) {
       const raw2 = r.accounts[j++];
       s.oracleAccount = feeds[i];
       if (raw2)
-        s.oracle = decodeOracleCanonical(fromBase648(raw2.data[0])) ?? void 0;
+        s.oracle = decodeOracleCanonical(fromBase6410(raw2.data[0])) ?? void 0;
     });
   }
   return { slot, yieldVault, strategies };
@@ -46291,7 +47931,7 @@ function createSolsticeAppApi(opts = {}) {
 }
 
 // src/vaults/solstice/math.ts
-var SECONDS_PER_YEAR2 = 31536000n;
+var SECONDS_PER_YEAR3 = 31536000n;
 var bigMax0 = (v) => v > 0n ? v : 0n;
 function unvestedAt(amount, start, end, now) {
   if (start === 0n && end === 0n) return 0n;
@@ -46330,7 +47970,7 @@ function eusxAssetsToShares(assets, r) {
 function epochRatePercent(vesting, assetsIncludingVesting, epochSeconds) {
   const principal = assetsIncludingVesting - vesting;
   if (vesting < 0n || principal <= 0n || epochSeconds <= 0n) return void 0;
-  const perYear = Number(SECONDS_PER_YEAR2) / Number(epochSeconds);
+  const perYear = Number(SECONDS_PER_YEAR3) / Number(epochSeconds);
   return Number(vesting) / Number(principal) * perYear * 100;
 }
 var eusxEpochRatePercent = (pool, vesting) => epochRatePercent(
@@ -46389,7 +48029,7 @@ function strategyMode(s, oraclePriceUsd, priceDecimals = 6) {
 import {
   createSvmFetchers,
   createSvmRpc as createSvmRpc3,
-  fromBase64 as fromBase649
+  fromBase64 as fromBase6411
 } from "@1delta/svm-kit";
 var SCALE = 10 ** SOLSTICE_DECIMALS;
 var fmt3 = (raw2) => Number(raw2) / SCALE;
@@ -46413,7 +48053,7 @@ async function fetchSolsticeSettlementBatches(rpc, strategyName, juniorQueueTime
   );
   const out = [];
   for (const r of rows) {
-    const b = decodeSettlementBatch(fromBase649(r.account.data[0]));
+    const b = decodeSettlementBatch(fromBase6411(r.account.data[0]));
     if (strategyNameOf(b.strategy_name) !== strategyName) continue;
     const settlementTime = Number(b.settlement_time);
     out.push({
@@ -46719,7 +48359,7 @@ async function fetchSolsticeVaults(opts = {}) {
 // src/vaults/solstice/fetchUser.ts
 import {
   createSvmRpc as createSvmRpc4,
-  fromBase64 as fromBase6410,
+  fromBase64 as fromBase6412,
   getAssociatedTokenAddress as getAssociatedTokenAddress2,
   TOKEN_PROGRAM
 } from "@1delta/svm-kit";
@@ -46760,10 +48400,10 @@ async function fetchSolsticeUser(account, opts = {}) {
   const { slot, accounts } = await rpc.readAccounts(keys);
   let i = 0;
   const next = () => accounts[i++] ?? null;
-  const bytes = (a) => a ? fromBase6410(a.data[0]) : void 0;
+  const bytes2 = (a) => a ? fromBase6412(a.data[0]) : void 0;
   const holdings = [];
   rows.forEach((r, k) => {
-    const d2 = bytes(next());
+    const d2 = bytes2(next());
     if (!d2) return;
     const shares = tokenAmount(d2);
     if (shares === 0n) return;
@@ -46785,7 +48425,7 @@ async function fetchSolsticeUser(account, opts = {}) {
   const pending = [];
   const usd = (raw2, r) => Number(raw2) / 10 ** r.assetDecimals * (r.priceUsd ?? 0);
   if (eusx && escrow) {
-    const d2 = bytes(next());
+    const d2 = bytes2(next());
     if (d2) {
       const e = decodeCooldownEscrow(d2);
       if (e.asset_amount > 0n)
@@ -46803,7 +48443,7 @@ async function fetchSolsticeUser(account, opts = {}) {
     }
   }
   seniors.forEach((r, k) => {
-    const d2 = bytes(next());
+    const d2 = bytes2(next());
     if (!d2) return;
     const c = decodeSeniorUnlockCooldown(d2);
     if (c.assets_pending === 0n) return;
@@ -46823,7 +48463,7 @@ async function fetchSolsticeUser(account, opts = {}) {
     });
   });
   for (const j of juniorRecords) {
-    const d2 = bytes(next());
+    const d2 = bytes2(next());
     if (!d2) continue;
     const u = decodeJuniorUnlockShare(d2);
     if (u.shares === 0n) continue;
@@ -62924,10 +64564,10 @@ var HUMA_SEEDS = {
 
 // src/vaults/huma/accounts.ts
 import {
-  decodeBase58 as decodeBase585,
-  decodeIdlAccount as decodeIdlAccount6,
-  findProgramAddress as findProgramAddress5,
-  fromBase64 as fromBase6411,
+  decodeBase58 as decodeBase586,
+  decodeIdlAccount as decodeIdlAccount7,
+  findProgramAddress as findProgramAddress6,
+  fromBase64 as fromBase6413,
   getAssociatedTokenAddress as getAssociatedTokenAddress3,
   TOKEN_PROGRAM as TOKEN_PROGRAM2
 } from "@1delta/svm-kit";
@@ -62943,21 +64583,21 @@ var HUMA_POOL = {
 var HUMA_MPST_MINT = "HUPfpnsaJtJGpJxAPNX1vXah7BgYiQYt1c2JMgMumvPs";
 var HUMA_CLASSIC_MODE_ID = "Fr2BGzmFkufAUXNWSWk79juyWrHVCj8AbyzbbvZzhwgz";
 var HUMA_DECIMALS = 6;
-var utf85 = (s) => new TextEncoder().encode(s);
-var pk5 = (address) => {
-  const b = decodeBase585(address);
+var utf86 = (s) => new TextEncoder().encode(s);
+var pk6 = (address) => {
+  const b = decodeBase586(address);
   if (!b || b.length !== 32) throw new Error(`huma: bad pubkey ${address}`);
   return b;
 };
-var pda2 = (seeds) => findProgramAddress5(seeds, HUMA_PROGRAM).then((r) => r.address);
-var humaPoolConfigPda = () => pda2([utf85("pool_config"), pk5(HUMA_POOL.poolId)]);
-var humaPoolStatePda = () => pda2([utf85("pool_state"), pk5(HUMA_POOL.poolConfig)]);
-var humaPoolAuthorityPda = () => pda2([utf85("pool_authority"), pk5(HUMA_POOL.poolConfig)]);
-var humaModeConfigPda = (modeId) => pda2([utf85("mode_config"), pk5(HUMA_POOL.poolConfig), pk5(modeId)]);
-var humaModeMintPda = (modeConfig) => pda2([utf85("mode_mint"), pk5(HUMA_POOL.poolConfig), pk5(modeConfig)]);
-var humaLenderStatePda = (modeConfig, lender) => pda2([utf85("lender_state"), pk5(modeConfig), pk5(lender)]);
-var humaDeploymentStatePda = (deploymentConfig) => pda2([utf85("deployment_state"), pk5(deploymentConfig)]);
-var humaRedemptionRequestPda = (id, poolConfig) => pda2([utf85("redemption_request"), u128be(id), pk5(poolConfig)]);
+var pda2 = (seeds) => findProgramAddress6(seeds, HUMA_PROGRAM).then((r) => r.address);
+var humaPoolConfigPda = () => pda2([utf86("pool_config"), pk6(HUMA_POOL.poolId)]);
+var humaPoolStatePda = () => pda2([utf86("pool_state"), pk6(HUMA_POOL.poolConfig)]);
+var humaPoolAuthorityPda = () => pda2([utf86("pool_authority"), pk6(HUMA_POOL.poolConfig)]);
+var humaModeConfigPda = (modeId) => pda2([utf86("mode_config"), pk6(HUMA_POOL.poolConfig), pk6(modeId)]);
+var humaModeMintPda = (modeConfig) => pda2([utf86("mode_mint"), pk6(HUMA_POOL.poolConfig), pk6(modeConfig)]);
+var humaLenderStatePda = (modeConfig, lender) => pda2([utf86("lender_state"), pk6(modeConfig), pk6(lender)]);
+var humaDeploymentStatePda = (deploymentConfig) => pda2([utf86("deployment_state"), pk6(deploymentConfig)]);
+var humaRedemptionRequestPda = (id, poolConfig) => pda2([utf86("redemption_request"), u128be(id), pk6(poolConfig)]);
 var u128be = (v) => {
   if (v < 0n || v >= 1n << 128n) throw new Error(`huma: id out of u128: ${v}`);
   const out = new Uint8Array(16);
@@ -62965,11 +64605,11 @@ var u128be = (v) => {
     out[15 - i] = Number(v >> BigInt(8 * i) & 0xffn);
   return out;
 };
-var decodeHumaPoolState = (d2) => decodeIdlAccount6(HUMA_IDL, "PoolState", d2);
-var decodeHumaModeConfig = (d2) => decodeIdlAccount6(HUMA_IDL, "ModeConfig", d2);
-var decodeHumaPoolConfig = (d2) => decodeIdlAccount6(HUMA_IDL, "PoolConfig", d2);
-var decodeHumaLenderState = (d2) => decodeIdlAccount6(HUMA_IDL, "LenderState", d2);
-var decodeHumaRedemptionRequest = (d2) => decodeIdlAccount6(HUMA_IDL, "RedemptionRequest", d2);
+var decodeHumaPoolState = (d2) => decodeIdlAccount7(HUMA_IDL, "PoolState", d2);
+var decodeHumaModeConfig = (d2) => decodeIdlAccount7(HUMA_IDL, "ModeConfig", d2);
+var decodeHumaPoolConfig = (d2) => decodeIdlAccount7(HUMA_IDL, "PoolConfig", d2);
+var decodeHumaLenderState = (d2) => decodeIdlAccount7(HUMA_IDL, "LenderState", d2);
+var decodeHumaRedemptionRequest = (d2) => decodeIdlAccount7(HUMA_IDL, "RedemptionRequest", d2);
 function mintSupply2(data) {
   if (data.length < 44) throw new Error("huma: mint account too short");
   return data.slice(36, 44).reduce((a, b, i) => a | BigInt(b) << BigInt(8 * i), 0n);
@@ -62993,13 +64633,13 @@ async function readHumaChainState(rpc, pool = HUMA_POOL) {
     { encoding: "base64" }
   );
   const state = decodeHumaPoolState(
-    fromBase6411(need2(first[0], "pool_state").data[0])
+    fromBase6413(need2(first[0], "pool_state").data[0])
   );
   const config = decodeHumaPoolConfig(
-    fromBase6411(need2(first[1], "pool_config").data[0])
+    fromBase6413(need2(first[1], "pool_config").data[0])
   );
   const poolCash = tokenAmount2(
-    first[2] ? fromBase6411(first[2].data[0]) : void 0
+    first[2] ? fromBase6413(first[2].data[0]) : void 0
   );
   const modeMints = await Promise.all(
     state.mode_config_keys.map((k) => humaModeMintPda(k))
@@ -63014,9 +64654,9 @@ async function readHumaChainState(rpc, pool = HUMA_POOL) {
     { encoding: "base64" }
   );
   const modeConfig = decodeHumaModeConfig(
-    fromBase6411(need2(modeAcct, "mode_config").data[0])
+    fromBase6413(need2(modeAcct, "mode_config").data[0])
   );
-  const mintData = fromBase6411(need2(mintAcct, "pst_mint").data[0]);
+  const mintData = fromBase6413(need2(mintAcct, "pst_mint").data[0]);
   const next = state.redemption.next_request_id;
   const last = state.redemption.last_request_id;
   const gate = state.redemption.global_redemption_gating;
@@ -63073,7 +64713,7 @@ async function readHumaLenderState(rpc, modeConfig, wallet) {
   const a = accounts[0];
   return {
     address,
-    state: a ? decodeHumaLenderState(fromBase6411(a.data[0])) : null
+    state: a ? decodeHumaLenderState(fromBase6413(a.data[0])) : null
   };
 }
 var HUMA_REDEMPTION_REQUEST_SIZE = 273;
@@ -63089,7 +64729,7 @@ async function readHumaRedemptionRequests(fetchers, wallet) {
   );
   return rows.map((r) => ({
     address: r.pubkey,
-    ...decodeHumaRedemptionRequest(fromBase6411(r.account.data[0]))
+    ...decodeHumaRedemptionRequest(fromBase6413(r.account.data[0]))
   })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
 }
 
@@ -63209,16 +64849,16 @@ var nowSec = () => Math.floor(Date.now() / 1e3);
 function convertLoopscaleVault(v, opts = {}) {
   const s = v.vaultStrategy.strategy;
   const listed3 = opts.tokenList?.[s.principalMint];
-  const dec = opts.decimals ?? listed3?.decimals;
-  if (dec === void 0) return void 0;
+  const dec2 = opts.decimals ?? listed3?.decimals;
+  if (dec2 === void 0) return void 0;
   const tvlRaw = strategyTvlRaw(s);
-  const tvl = tvlRaw / 10 ** dec;
+  const tvl = tvlRaw / 10 ** dec2;
   const extAmount = Number(s.externalYieldAmount);
   const deployed = Number(s.currentDeployedAmount);
   const idle = Number(s.tokenBalance);
   const ext = v.vaultStrategy.externalYieldInfo;
   const extApr = ext ? cbpsToFraction(ext.apy) : 0;
-  const grossAnnual = Number(s.interestPerSecond) * SECONDS_PER_YEAR + extApr * extAmount;
+  const grossAnnual = Number(s.interestPerSecond) * SECONDS_PER_YEAR2 + extApr * extAmount;
   const gross = tvlRaw > 0 ? grossAnnual / tvlRaw * 100 : 0;
   const feeFrac = cbpsToFraction(s.interestFee);
   const supplyRate = gross * (1 - feeFrac);
@@ -63235,7 +64875,7 @@ function convertLoopscaleVault(v, opts = {}) {
     const rDec = mint ? opts.tokenList?.[mint]?.decimals : void 0;
     if (!p || rDec === void 0 || !priceUsd || tvl <= 0) continue;
     const perSec = Number(r.emissionsPerSecond ?? 0) / 10 ** rDec;
-    rewardsRate += perSec * SECONDS_PER_YEAR * p / (tvl * priceUsd) * 100;
+    rewardsRate += perSec * SECONDS_PER_YEAR2 * p / (tvl * priceUsd) * 100;
   }
   const lp = Number(v.vault.lpSupply);
   const earlyFee = Number(v.vault.maxEarlyUnstakeFee);
@@ -63255,13 +64895,15 @@ function convertLoopscaleVault(v, opts = {}) {
     name: meta?.name ?? v.vault.address,
     displayName: meta?.name ? `Loopscale ${meta.name}` : `Loopscale ${sym}`,
     curatorName: meta?.managerName ?? "Loopscale",
-    decimals: dec,
-    assetDecimals: dec,
+    manager: v.vault.manager,
+    managerImage: meta?.managerImage ?? void 0,
+    decimals: dec2,
+    assetDecimals: dec2,
     totalAssets: String(tvlRaw),
     totalSupply: String(lp),
-    convertToAssets: String(Math.round(sharePrice * 10 ** dec)),
+    convertToAssets: String(Math.round(sharePrice * 10 ** dec2)),
     convertToShares: String(
-      sharePrice > 0 ? Math.round(1 / sharePrice * 10 ** dec) : 0
+      sharePrice > 0 ? Math.round(1 / sharePrice * 10 ** dec2) : 0
     ),
     grossRate: gross,
     supplyRate,
@@ -63273,8 +64915,8 @@ function convertLoopscaleVault(v, opts = {}) {
     totalAssetsFormatted: tvl,
     totalAssetsUsd: sum?.totalSupplyUsd ?? tvl * (priceUsd ?? 0),
     liquidity: String(idle),
-    liquidityFormatted: idle / 10 ** dec,
-    liquidityUsd: idle / 10 ** dec * (priceUsd ?? 0),
+    liquidityFormatted: idle / 10 ** dec2,
+    liquidityUsd: idle / 10 ** dec2 * (priceUsd ?? 0),
     sharePrice,
     sharePriceUsd: sharePrice * (priceUsd ?? 0),
     yieldProfile: "yield-bearing",
@@ -63342,6 +64984,158 @@ async function fetchLoopscaleEarnVaults(opts = {}) {
   return out;
 }
 
+// src/vaults/kamino-kvault/api.ts
+var KVAULT_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+function createKaminoKvaultApi(opts = {}) {
+  const base = (opts.baseUrl ?? KAMINO_API_BASE).replace(/\/$/, "");
+  const limit = createLimiter(opts.maxInFlight ?? 4);
+  const get = (path) => limit(() => getJson(`${base}${path}`, opts));
+  return {
+    vaults: () => get("/kvaults/vaults"),
+    /** Every page of the batch metrics. A page that fails fails the call — a partial metrics set would read as vaults with no APY. */
+    metrics: async () => {
+      const out = [];
+      let token;
+      const maxPages = opts.maxPages ?? 20;
+      for (let page = 0; page < maxPages; page++) {
+        const res = await get(
+          `/kvaults/vaults/metrics${token ? `?paginationToken=${encodeURIComponent(token)}` : ""}`
+        );
+        out.push(...res.result ?? []);
+        token = res.paginationToken ?? void 0;
+        if (!token || !res.result?.length) return out;
+      }
+      throw new Error(
+        `kvault metrics: still paging after ${maxPages} pages (${out.length} rows)`
+      );
+    },
+    vaultMetrics: (vault) => get(`/kvaults/vaults/${vault}/metrics`)
+  };
+}
+
+// src/vaults/kamino-kvault/fetchPublic.ts
+function decimalStringToRaw(s, decimals) {
+  if (s === void 0 || s === null) return void 0;
+  const t = String(s).trim();
+  const m = /^(-?)(\d*)(?:\.(\d*))?$/.exec(t);
+  if (!m || !m[2] && !m[3]) return void 0;
+  const frac = (m[3] ?? "").slice(0, decimals).padEnd(decimals, "0");
+  const v = BigInt((m[2] || "0") + frac);
+  return m[1] ? -v : v;
+}
+function convertKaminoKvault(v, m, opts = {}) {
+  if (!m) return void 0;
+  const s = v.state;
+  const dec2 = s.tokenMintDecimals;
+  const shareDec = s.sharesMintDecimals;
+  const listed3 = opts.tokenList?.[s.tokenMint];
+  const listedShare = opts.tokenList?.[s.sharesMint];
+  const sym = listed3?.symbol ?? s.tokenMint.slice(0, 4);
+  const perShare = num(m.tokensPerShare, 1);
+  const shares = BigInt(s.sharesIssued || "0");
+  const perShareRaw = decimalStringToRaw(m.tokensPerShare, dec2) ?? 10n ** BigInt(dec2);
+  const totalAssetsRaw = shares * perShareRaw / 10n ** BigInt(shareDec);
+  const totalAssetsFormatted = Number(totalAssetsRaw) / 10 ** dec2;
+  const idleRaw = BigInt(s.tokenAvailable || "0");
+  const idle = Number(idleRaw) / 10 ** dec2;
+  const price = num(m.tokenPrice);
+  const priced = price > 0;
+  const apy = {
+    current: num(m.apy),
+    actual: num(m.apyActual),
+    d1: num(m.apy24h),
+    d7: num(m.apy7d),
+    d30: num(m.apy30d),
+    d90: num(m.apy90d),
+    farmRewards: num(m.apyFarmRewards),
+    incentives: num(m.apyIncentives),
+    reservesIncentives: num(m.apyReservesIncentives)
+  };
+  const supplyRate = apyFractionToAprPercent(apy.current);
+  const rewardsRate = apyFractionToAprPercent(apy.farmRewards + apy.incentives);
+  const name = s.name?.trim() || listedShare?.name || `Kamino Vault ${sym}`;
+  return {
+    provider: "kamino-kvault",
+    originProvider: "kamino-kvault",
+    chainId: SOLANA_CHAIN_ID,
+    address: v.address,
+    shareMint: s.sharesMint,
+    underlying: s.tokenMint,
+    symbol: listedShare?.symbol ?? `kv${sym}`,
+    name,
+    displayName: name.toLowerCase().includes("kamino") ? name : `Kamino ${name}`,
+    curatorName: s.vaultAdminAuthority,
+    manager: s.vaultAdminAuthority,
+    allocationAdmin: s.allocationAdmin,
+    decimals: shareDec,
+    assetDecimals: dec2,
+    totalAssets: totalAssetsRaw.toString(),
+    totalSupply: shares.toString(),
+    convertToAssets: perShareRaw.toString(),
+    convertToShares: perShare > 0 ? String(Math.round(1 / perShare * 10 ** shareDec)) : "0",
+    supplyRate,
+    rewardsRate,
+    depositRate: supplyRate + rewardsRate,
+    asset: listed3,
+    priceUsd: priced ? price : void 0,
+    totalAssetsFormatted,
+    totalAssetsUsd: priced ? totalAssetsFormatted * price : 0,
+    liquidity: idleRaw.toString(),
+    liquidityFormatted: idle,
+    liquidityUsd: priced ? idle * price : 0,
+    sharePrice: perShare,
+    sharePriceUsd: priced ? num(m.sharePrice, perShare * price) : 0,
+    yieldProfile: "yield-bearing",
+    denomination: denominationOf({
+      symbol: listed3?.symbol,
+      props: listed3?.props
+    }),
+    logoURI: listedShare?.logoURI ?? listed3?.logoURI,
+    fee: s.performanceFeeBps / 100,
+    managementFeePct: s.managementFeeBps / 100,
+    withdrawalMode: "instant-capped",
+    instantLiquidityRatio: totalAssetsRaw > 0n ? Math.min(1, Number(idleRaw * 1000000n / totalAssetsRaw) / 1e6) : 1,
+    apy,
+    holders: m.numberOfHolders ?? 0,
+    vaultFarm: s.vaultFarm && s.vaultFarm !== "11111111111111111111111111111111" ? s.vaultFarm : void 0,
+    allocations: (s.vaultAllocationStrategy ?? []).filter((a) => a.reserve !== "11111111111111111111111111111111").map((a) => ({
+      reserve: a.reserve,
+      weight: a.targetAllocationWeight,
+      ctokenAllocation: a.ctokenAllocation
+    })),
+    createdAt: s.creationTimestamp,
+    minDepositAmount: s.minDepositAmount
+  };
+}
+async function fetchKaminoKvaults(opts = {}) {
+  const api = createKaminoKvaultApi(opts);
+  const [vaults, metrics] = await Promise.all([
+    opts.vaults ?? api.vaults(),
+    opts.metrics ?? api.metrics()
+  ]);
+  const byVault = /* @__PURE__ */ new Map();
+  for (const m of metrics) if (m.kvault) byVault.set(m.kvault, m);
+  const out = [];
+  const skipped = [];
+  for (const v of vaults) {
+    if (!opts.includeEmpty && BigInt(v.state.sharesIssued || "0") === 0n)
+      continue;
+    const row = convertKaminoKvault(v, byVault.get(v.address), {
+      tokenList: opts.tokenList
+    });
+    if (!row) {
+      skipped.push(v.address);
+      continue;
+    }
+    out.push(row);
+  }
+  if (skipped.length)
+    console.warn(
+      `[kamino-kvault] ${skipped.length} vault(s) skipped \u2014 no metrics row: ${skipped.join(", ")}`
+    );
+  return out;
+}
+
 // src/vaults/lst/fetchPublic.ts
 import { createSvmRpc as createSvmRpc6, WRAPPED_SOL } from "@1delta/svm-kit";
 var LAMPORTS_PER_SOL = 10 ** 9;
@@ -63360,7 +65154,7 @@ var SPL_STAKE_POOL_LSTS = [
     curatorName: "SolBlaze"
   }
 ];
-var SECONDS_PER_YEAR3 = 365.25 * 86400;
+var SECONDS_PER_YEAR4 = 365.25 * 86400;
 function epochRealizedApr(pool, epochSeconds) {
   if (pool.lastEpochTotalLamports === void 0 || !pool.lastEpochPoolTokenSupply || pool.poolTokenSupply === 0n || epochSeconds <= 0)
     return void 0;
@@ -63370,7 +65164,7 @@ function epochRealizedApr(pool, epochSeconds) {
   const epochRate = now / last - 1;
   return {
     epochRatePercent: epochRate * 100,
-    aprPercent: epochRate * (SECONDS_PER_YEAR3 / epochSeconds) * 100,
+    aprPercent: epochRate * (SECONDS_PER_YEAR4 / epochSeconds) * 100,
     lastEpochExchangeRate: last
   };
 }
@@ -63657,6 +65451,9 @@ function loopscaleOriginRow(r) {
     meta: {
       vaultAccount: r.vaultAccount,
       strategy: r.strategy,
+      manager: r.manager,
+      managerName: r.curatorName,
+      managerImage: r.managerImage,
       grossRate: r.grossRate,
       venueApy: r.venueApy,
       interestFee: r.fees.interest,
@@ -63681,6 +65478,42 @@ function loopscaleOriginRow(r) {
     }
   };
 }
+function kaminoKvaultOriginRow(r) {
+  return {
+    ...common4626(r, "kamino-kvault", "sync"),
+    // kvaults publish no curator NAME: `r.curatorName` is the admin address,
+    // and a brand column holding a base58 key would read as the desk's name on
+    // /earn. The address travels as `meta.manager`; a label layer keyed by it
+    // (lender-metadata curator-labels.json → curator_metadata) names it.
+    curatorName: void 0,
+    provider: "kamino-kvault",
+    fee: r.fee,
+    shareAsset: {
+      chainId: r.chainId,
+      address: r.shareMint,
+      symbol: r.symbol,
+      name: r.name,
+      decimals: r.decimals
+    },
+    metaTable: "vault_kamino_kvault_meta",
+    meta: {
+      shareMint: r.shareMint,
+      manager: r.manager,
+      allocationAdmin: r.allocationAdmin,
+      managementFeePct: r.managementFeePct,
+      convertToAssets: r.convertToAssets,
+      convertToShares: r.convertToShares,
+      withdrawalMode: r.withdrawalMode,
+      instantLiquidityRatio: r.instantLiquidityRatio,
+      apy: r.apy,
+      holders: r.holders,
+      vaultFarm: r.vaultFarm,
+      allocations: r.allocations,
+      createdAt: r.createdAt,
+      minDepositAmount: r.minDepositAmount
+    }
+  };
+}
 function exponentOriginRow(r) {
   return {
     provider: "exponent",
@@ -63728,6 +65561,8 @@ function toOriginVaultRow(r) {
       return jupiterLendOriginRow(r);
     case "loopscale":
       return loopscaleOriginRow(r);
+    case "kamino-kvault":
+      return kaminoKvaultOriginRow(r);
   }
 }
 
@@ -63893,21 +65728,66 @@ async function fetchJupiterLendOracleEntries(opts = {}) {
 }
 
 // src/prices/oracle-prices/fetchers/save.ts
+import { createSvmRpc as createSvmRpc7 } from "@1delta/svm-kit";
 async function fetchSaveOracleEntries(opts = {}) {
   const res = opts.publicData ?? await fetchSavePublic(opts);
+  const feeds = /* @__PURE__ */ new Set();
+  for (const bundle of Object.values(res))
+    for (const row of Object.values(bundle.data)) {
+      if (row.save.pythOracle) feeds.add(row.save.pythOracle);
+      if (row.save.switchboardOracle) feeds.add(row.save.switchboardOracle);
+    }
+  const readings = /* @__PURE__ */ new Map();
+  if (opts.live !== false && feeds.size) {
+    try {
+      const rpc = opts.rpc ?? createSvmRpc7();
+      const keys = [...feeds];
+      const { accounts } = await rpc.readAccounts(keys, { encoding: "base64" });
+      accounts.forEach((a, i) => {
+        if (!a) return;
+        try {
+          const r = decodeOracleFeed({ owner: a.owner, data: a.data[0] });
+          if (r && Number.isFinite(r.price) && r.price > 0)
+            readings.set(keys[i], r);
+        } catch (e) {
+          console.warn(`[save] feed ${keys[i]}: ${e.message}`);
+        }
+      });
+    } catch (e) {
+      console.warn(
+        `[save] live feeds not read, serving stored reserve prices: ${e.message}`
+      );
+    }
+  }
   const out = {};
   for (const [lender, bundle] of Object.entries(res)) {
     out[lender] = Object.entries(bundle.data).map(([marketUid, row]) => {
       const s = row.save;
+      const bps = s.scaledPriceOffsetBps;
+      const dial = bps !== 0 ? ` \xD7 (1 + ${bps} bps dial)` : "";
+      const candidates = [s.pythOracle, s.switchboardOracle].filter((k) => !!k && readings.has(k)).map((k) => ({ feed: k, r: readings.get(k) })).sort((a, b) => b.r.updatedAt - a.r.updatedAt);
+      const pick = candidates[0];
+      if (pick) {
+        const price = pick.r.price * (1 + bps / 1e4);
+        return {
+          asset: row.underlying,
+          price,
+          priceUSD: price,
+          marketUid,
+          description: `Save reserve oracle \xB7 ${pick.r.kind}${dial} (live feed read)`,
+          derivation: dial ? "derived" : "direct",
+          feedSource: pick.feed,
+          feedUpdatedAt: pick.r.updatedAt > 0 ? pick.r.updatedAt : void 0
+        };
+      }
       const feed = s.pythOracle ?? s.switchboardOracle ?? s.extraOracle;
       const kind = s.pythOracle ? "pyth-pull" : s.switchboardOracle ? "switchboard-on-demand" : "extra";
-      const dial = s.scaledPriceOffsetBps !== 0 ? ` \xD7 (1 + ${s.scaledPriceOffsetBps} bps dial)` : "";
       return {
         asset: row.underlying,
         price: s.priceUsd,
         priceUSD: s.priceUsd,
         marketUid,
-        description: `Save reserve price \xB7 ${kind}${dial} \xB7 slot ${s.lastUpdateSlot}${s.stale ? " (stale)" : ""}`,
+        description: `Save reserve price (stored) \xB7 ${kind}${dial} \xB7 slot ${s.lastUpdateSlot}${s.stale ? " (stale)" : ""}`,
         derivation: dial ? "derived" : "direct",
         feedSource: feed
       };
@@ -63967,16 +65847,19 @@ async function fetchProject0OracleEntries(opts = {}) {
   for (const [lender, bundle] of Object.entries(res)) {
     out[lender] = Object.entries(bundle.data).filter(([, row]) => row.p0.price.source !== "none").map(([marketUid, row]) => {
       const p = row.p0.price;
-      return {
+      const fixed = p.source === "fixed";
+      const entry = {
         asset: row.underlying,
         price: p.priceUsd,
         priceUSD: p.priceUsd,
         marketUid,
         description: `Project 0 \xB7 ${p.description ?? p.source}`,
-        derivation: p.source === "pyth-push" ? "direct" : p.source === "fixed" ? "direct" : "derived",
+        derivation: p.source === "pyth-push" || p.source === "scope" || fixed ? "direct" : "derived",
         feedSource: p.feed,
         feedUpdatedAt: p.updatedAt
       };
+      if (fixed) entry.staticBase = true;
+      return entry;
     });
   }
   return out;
@@ -63987,14 +65870,15 @@ async function fetchOraclePrices(chainIds, opts = {}) {
   const FETCHERS = {
     kamino: (chainId) => chainId === SOLANA_CHAIN_ID ? fetchKaminoOracleEntries(opts.overrides, opts) : Promise.resolve({}),
     "jupiter-lend": (chainId) => chainId === SOLANA_CHAIN_ID ? fetchJupiterLendOracleEntries(opts) : Promise.resolve({}),
-    save: (chainId) => chainId === SOLANA_CHAIN_ID ? fetchSaveOracleEntries({ timeoutMs: opts.timeoutMs }) : Promise.resolve({}),
+    save: (chainId) => chainId === SOLANA_CHAIN_ID ? fetchSaveOracleEntries({ timeoutMs: opts.timeoutMs, rpc: opts.rpc }) : Promise.resolve({}),
     loopscale: (chainId) => chainId === SOLANA_CHAIN_ID ? fetchLoopscaleOracleEntries({
       timeoutMs: opts.timeoutMs,
       tokenList: opts.tokenList
     }) : Promise.resolve({}),
     project0: (chainId) => chainId === SOLANA_CHAIN_ID ? fetchProject0OracleEntries({
       timeoutMs: opts.timeoutMs,
-      tokenList: opts.tokenList
+      tokenList: opts.tokenList,
+      ...opts.rpc ? { rpc: opts.rpc } : {}
     }) : Promise.resolve({})
   };
   const names = opts.onlyFetchers?.length ? opts.onlyFetchers : Object.keys(FETCHERS);
@@ -64275,10 +66159,10 @@ async function mintToReserve(api, market) {
 // src/lending/user-data/kamino/onchain.ts
 import {
   createSvmFetchers as createSvmFetchers2,
-  createSvmRpc as createSvmRpc7,
-  decodeIdlAccount as decodeIdlAccount7,
+  createSvmRpc as createSvmRpc8,
+  decodeIdlAccount as decodeIdlAccount8,
   encodeBase58 as encodeBase586,
-  fromBase64 as fromBase6412
+  fromBase64 as fromBase6414
 } from "@1delta/svm-kit";
 var KLEND_OBLIGATION_SIZE = 3344;
 var KLEND_OBLIGATION_DISCRIMINATOR = [
@@ -64297,7 +66181,7 @@ var SF = 60n;
 var bsf = (b) => b.value.reduce((a, w, i) => a + (BigInt(w) << 64n * BigInt(i)), 0n);
 var sfToNumber = (x) => Number(x >> 30n) / 2 ** 30;
 function decodeKaminoObligation(address, data) {
-  const o = decodeIdlAccount7(KLEND_IDL, "Obligation", data);
+  const o = decodeIdlAccount8(KLEND_IDL, "Obligation", data);
   return {
     address,
     owner: o.owner,
@@ -64325,7 +66209,7 @@ function decodeKaminoObligation(address, data) {
   };
 }
 function decodeKaminoReserveState(reserve, data) {
-  const r = decodeIdlAccount7(KLEND_IDL, "Reserve", data);
+  const r = decodeIdlAccount8(KLEND_IDL, "Reserve", data);
   const l = r.liquidity;
   const totalSf = klendTotalSupplySf({
     availableAmount: BigInt(l.totalAvailableAmount),
@@ -64394,7 +66278,7 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
         obligation: o.address,
         reason: `elevation group ${o.elevationGroup} terms not read \u2014 health uses the reserves' own LT`
       });
-    const view = {
+    const view2 = {
       address: o.address,
       market: o.market,
       lenderKey,
@@ -64425,7 +66309,7 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
       const units = depositUnits(d2.cTokens, s);
       const amount = Number(units);
       const uid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, d2.reserve);
-      view.deposits.push({
+      view2.deposits.push({
         reserve: d2.reserve,
         marketUid: uid,
         mint: s.mint,
@@ -64433,10 +66317,10 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
         amount,
         amountUsd: amount * s.priceUsd
       });
-      view.asOfSlot = Math.min(view.asOfSlot, s.lastUpdateSlot);
-      view.depositedValueUsd += amount * s.priceUsd;
+      view2.asOfSlot = Math.min(view2.asOfSlot, s.lastUpdateSlot);
+      view2.depositedValueUsd += amount * s.priceUsd;
       const lt = group?.liquidationThreshold ?? s.liquidationThresholdPct;
-      view.unhealthyBorrowValueUsd += amount * s.priceUsd * lt / 100;
+      view2.unhealthyBorrowValueUsd += amount * s.priceUsd * lt / 100;
       const p = leg(uid);
       p.deposits = units;
       p.depositsUSD = amount * s.priceUsd;
@@ -64459,7 +66343,7 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
       const units = debtUnits(debtSf, s);
       const amount = Number(units);
       const uid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, b.reserve);
-      view.borrows.push({
+      view2.borrows.push({
         reserve: b.reserve,
         marketUid: uid,
         mint: s.mint,
@@ -64467,17 +66351,17 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
         amount,
         amountUsd: amount * s.priceUsd
       });
-      view.asOfSlot = Math.min(view.asOfSlot, s.lastUpdateSlot);
-      view.bfAdjustedDebtUsd += amount * s.priceUsd * (o.elevationGroup ? 100 : Math.max(100, s.borrowFactorPct)) / 100;
+      view2.asOfSlot = Math.min(view2.asOfSlot, s.lastUpdateSlot);
+      view2.bfAdjustedDebtUsd += amount * s.priceUsd * (o.elevationGroup ? 100 : Math.max(100, s.borrowFactorPct)) / 100;
       const p = leg(uid);
       p.debt = units;
       p.debtUSD = amount * s.priceUsd;
       p.debtUSDOracle = amount * s.priceUsd;
     }
-    if (view.asOfSlot === Infinity) view.asOfSlot = o.lastUpdateSlot;
-    if (view.bfAdjustedDebtUsd > 0)
-      view.healthFactor = view.unhealthyBorrowValueUsd / view.bfAdjustedDebtUsd;
-    views.push(view);
+    if (view2.asOfSlot === Infinity) view2.asOfSlot = o.lastUpdateSlot;
+    if (view2.bfAdjustedDebtUsd > 0)
+      view2.healthFactor = view2.unhealthyBorrowValueUsd / view2.bfAdjustedDebtUsd;
+    views.push(view2);
     bucket.lendingPositions[o.address] = legs;
     bucket.modes[o.address] = String(o.elevationGroup);
     bucket.accounts[o.address] = accounts[o.address] ?? {
@@ -64498,7 +66382,7 @@ function valueKaminoObligations(account, obligations, reserves, groups = {}, acc
   };
 }
 async function fetchKaminoUserOnchain(account, opts = {}) {
-  const rpc = opts.rpc ?? createSvmRpc7();
+  const rpc = opts.rpc ?? createSvmRpc8();
   const hits = await createSvmFetchers2(rpc).indexed.scanProgram(
     KLEND_PROGRAM_ID,
     [
@@ -64517,7 +66401,7 @@ async function fetchKaminoUserOnchain(account, opts = {}) {
     }
   );
   const markets = opts.markets && new Set(opts.markets);
-  const obligations = hits.map((h) => decodeKaminoObligation(h.pubkey, fromBase6412(h.account.data[0]))).filter((o) => !markets || markets.has(o.market));
+  const obligations = hits.map((h) => decodeKaminoObligation(h.pubkey, fromBase6414(h.account.data[0]))).filter((o) => !markets || markets.has(o.market));
   const reserves = { ...opts.reserves };
   const need3 = [
     ...new Set(
@@ -64540,8 +66424,8 @@ async function fetchKaminoUserOnchain(account, opts = {}) {
       const a = accounts2[i];
       if (!a || a.owner !== KLEND_PROGRAM_ID) return;
       if (i < need3.length)
-        reserves[k] = decodeKaminoReserveState(k, fromBase6412(a.data[0]));
-      else groups[k] = readKlendElevationGroups(fromBase6412(a.data[0]));
+        reserves[k] = decodeKaminoReserveState(k, fromBase6414(a.data[0]));
+      else groups[k] = readKlendElevationGroups(fromBase6414(a.data[0]));
     });
   }
   const accounts = {};
@@ -64569,7 +66453,7 @@ async function fetchKaminoUserOnchain(account, opts = {}) {
 
 // src/lending/user-data/jupiter-lend/fetchUser.ts
 var isPositionId = (id) => typeof id === "number" && Number.isSafeInteger(id) && id > 0;
-var big = (v) => {
+var big2 = (v) => {
   try {
     return BigInt(v ?? 0);
   } catch {
@@ -64589,8 +66473,8 @@ function convertJupiterLendUserPositions(account, market, positions, vaults = /*
       skip("liquidated");
       continue;
     }
-    const supplyRaw = big(p.supply);
-    const borrowRaw = big(p.borrow) + big(p.dustBorrow);
+    const supplyRaw = big2(p.supply);
+    const borrowRaw = big2(p.borrow) + big2(p.dustBorrow);
     if (supplyRaw === 0n && borrowRaw === 0n) {
       skip("empty");
       continue;
@@ -64684,7 +66568,7 @@ async function fetchJupiterLendUser(account, opts = {}) {
       ext.borrowPositions[market] = borrows;
       ext.earnPositions[market] = earns;
       const needsRoster = borrows.some(
-        (p) => !p.isLiquidated && (big(p.supply) > 0n || big(p.borrow) + big(p.dustBorrow) > 0n) && !(p.vault && p.vault.id === p.vaultId)
+        (p) => !p.isLiquidated && (big2(p.supply) > 0n || big2(p.borrow) + big2(p.dustBorrow) > 0n) && !(p.vault && p.vault.id === p.vaultId)
       );
       const roster = needsRoster ? new Map((await api.vaults(market)).map((v) => [v.id, v])) : void 0;
       const conv = convertJupiterLendUserPositions(
@@ -64701,7 +66585,7 @@ async function fetchJupiterLendUser(account, opts = {}) {
 }
 
 // src/lending/user-data/save/obligation.ts
-import { BorshReader as BorshReader2, decodeBase58 as decodeBase586, encodeBase58 as encodeBase587 } from "@1delta/svm-kit";
+import { BorshReader as BorshReader2, decodeBase58 as decodeBase587, encodeBase58 as encodeBase587 } from "@1delta/svm-kit";
 function decodeSaveObligation(address, data) {
   if (data.length !== SAVE_OBLIGATION_SIZE)
     throw new Error(
@@ -64770,10 +66654,10 @@ function saveObligationSeed(lendingMarket, index = 0) {
     throw new Error(`save obligation index out of range: ${index}`);
   return lendingMarket.slice(0, 24) + String(index).padStart(6, "0") + "m";
 }
-var sha256 = async (bytes) => new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+var sha256 = async (bytes2) => new Uint8Array(await crypto.subtle.digest("SHA-256", bytes2));
 async function createWithSeed(base, seed, programId) {
-  const b = decodeBase586(base);
-  const p = decodeBase586(programId);
+  const b = decodeBase587(base);
+  const p = decodeBase587(programId);
   if (!b || b.length !== 32) throw new Error(`not a pubkey: ${base}`);
   if (!p || p.length !== 32) throw new Error(`not a pubkey: ${programId}`);
   const s = new TextEncoder().encode(seed);
@@ -64788,23 +66672,23 @@ var saveObligationAddress = (wallet, lendingMarket, index = 0, programId = SAVE_
 
 // src/lending/user-data/save/fetchUser.ts
 import {
-  createSvmRpc as createSvmRpc8,
+  createSvmRpc as createSvmRpc9,
   encodeBase58 as encodeBase588,
-  fromBase64 as fromBase6413,
+  fromBase64 as fromBase6415,
   getAssociatedTokenAddress as getAssociatedTokenAddress4,
   TOKEN_PROGRAM as TOKEN_PROGRAM3
 } from "@1delta/svm-kit";
 var SAVE_WALLET_POS_ID = "wallet";
-var readTokenAmount = (bytes, mint) => {
-  if (bytes.length < 72) return void 0;
-  if (encodeBase588(bytes.subarray(0, 32)) !== mint) return void 0;
+var readTokenAmount = (bytes2, mint) => {
+  if (bytes2.length < 72) return void 0;
+  if (encodeBase588(bytes2.subarray(0, 32)) !== mint) return void 0;
   let v = 0n;
-  for (let i = 71; i >= 64; i--) v = v << 8n | BigInt(bytes[i]);
+  for (let i = 71; i >= 64; i--) v = v << 8n | BigInt(bytes2[i]);
   return v;
 };
 async function fetchSaveUser(account, opts = {}) {
   const api = createSaveApi(opts);
-  const rpc = opts.rpc ?? createSvmRpc8();
+  const rpc = opts.rpc ?? createSvmRpc9();
   const configs = opts.configs ?? await api.marketConfigs();
   const markets = selectSaveMarkets(configs, opts);
   const step = Math.min(
@@ -64860,9 +66744,9 @@ async function fetchSaveUser(account, opts = {}) {
       const exists = !!a && a.owner === SAVE_PROGRAM_ID && typeof a.data?.[0] === "string";
       (probed[key2] ??= []).push({ index: c.index, address: c.address, exists });
       if (!exists) return;
-      const bytes = fromBase6413(a.data[0]);
-      if (bytes.length !== SAVE_OBLIGATION_SIZE) return;
-      found.push({ c, ob: decodeSaveObligation(c.address, bytes) });
+      const bytes2 = fromBase6415(a.data[0]);
+      if (bytes2.length !== SAVE_OBLIGATION_SIZE) return;
+      found.push({ c, ob: decodeSaveObligation(c.address, bytes2) });
     });
     if (extend)
       for (const c of pending) {
@@ -64883,7 +66767,7 @@ async function fetchSaveUser(account, opts = {}) {
     const a = ataAccounts[i];
     if (!a || a.owner !== TOKEN_PROGRAM3 || typeof a.data?.[0] !== "string")
       return;
-    const amount = readTokenAmount(fromBase6413(a.data[0]), c.cTokenMint);
+    const amount = readTokenAmount(fromBase6415(a.data[0]), c.cTokenMint);
     if (amount && amount > 0n) wallet.push({ c, cTokens: amount });
   });
   const reserveIds = [
@@ -64951,7 +66835,7 @@ async function fetchSaveUser(account, opts = {}) {
       address: ob.address,
       label: `#${c.index}`
     };
-    const view = {
+    const view2 = {
       address: ob.address,
       market: c.market.address,
       lenderKey,
@@ -64994,13 +66878,13 @@ async function fetchSaveUser(account, opts = {}) {
         });
         continue;
       }
-      const dec = s.reserve.liquidity.mintDecimals;
+      const dec2 = s.reserve.liquidity.mintDecimals;
       const raw2 = d2.depositedAmount * saveExchangeRateWad(s.reserve) / SAVE_WAD;
-      const amountStr = scaledToDecimal(raw2, dec);
+      const amountStr = scaledToDecimal(raw2, dec2);
       const amount = Number(amountStr);
       const price = wadToNumber(s.reserve.liquidity.marketPrice);
       const usd = amount * price;
-      view.deposits.push({
+      view2.deposits.push({
         reserve: d2.reserve,
         marketUid: uid,
         mint: s.reserve.liquidity.mintPubkey,
@@ -65009,10 +66893,10 @@ async function fetchSaveUser(account, opts = {}) {
         amountUsd: usd,
         served: !reason
       });
-      view.depositedValueUsd += usd;
-      view.allowedBorrowValueUsd += usd * (s.reserve.config.loanToValueRatio / 100);
-      view.unhealthyBorrowValueUsd += usd * (s.reserve.config.liquidationThreshold / 100);
-      view.superUnhealthyBorrowValueUsd += usd * (s.reserve.config.maxLiquidationThreshold / 100);
+      view2.depositedValueUsd += usd;
+      view2.allowedBorrowValueUsd += usd * (s.reserve.config.loanToValueRatio / 100);
+      view2.unhealthyBorrowValueUsd += usd * (s.reserve.config.liquidationThreshold / 100);
+      view2.superUnhealthyBorrowValueUsd += usd * (s.reserve.config.maxLiquidationThreshold / 100);
       if (reason) {
         unserved.push({
           lenderKey,
@@ -65052,18 +66936,18 @@ async function fetchSaveUser(account, opts = {}) {
         });
         continue;
       }
-      const dec = s.reserve.liquidity.mintDecimals;
+      const dec2 = s.reserve.liquidity.mintDecimals;
       const price = wadToNumber(s.reserve.liquidity.marketPrice);
       const reserveIdx = BigInt(s.reserve.liquidity.cumulativeBorrowRateWads);
       const legIdx = b.cumulativeBorrowRateWads;
       const wads = legIdx > 0n ? b.borrowedAmountWads * reserveIdx / legIdx : b.borrowedAmountWads;
-      const amountStr = scaledToDecimal(wads, 18 + dec);
+      const amountStr = scaledToDecimal(wads, 18 + dec2);
       const amount = Number(amountStr);
-      const atTouch = wadToNumber(b.borrowedAmountWads.toString()) / 10 ** dec;
+      const atTouch = wadToNumber(b.borrowedAmountWads.toString()) / 10 ** dec2;
       const usd = amount * price;
       const addedBps = s.reserve.config.addedBorrowWeightBPS;
       const weight = 1 + Number(addedBps) / 1e4;
-      view.borrows.push({
+      view2.borrows.push({
         reserve: b.reserve,
         marketUid: uid,
         mint: s.reserve.liquidity.mintPubkey,
@@ -65073,8 +66957,8 @@ async function fetchSaveUser(account, opts = {}) {
         borrowWeight: weight,
         served: !reason
       });
-      if (weight > 1e9 && wads > 0n) view.unboundedWeightDebt = true;
-      view.weightedBorrowValueUsd += usd * weight;
+      if (weight > 1e9 && wads > 0n) view2.unboundedWeightDebt = true;
+      view2.weightedBorrowValueUsd += usd * weight;
       if (reason) {
         unserved.push({
           lenderKey,
@@ -65095,8 +66979,8 @@ async function fetchSaveUser(account, opts = {}) {
         debtUSDOracle: usd
       });
     }
-    view.healthFactor = view.weightedBorrowValueUsd > 0 ? view.unhealthyBorrowValueUsd / view.weightedBorrowValueUsd : Infinity;
-    views.push(view);
+    view2.healthFactor = view2.weightedBorrowValueUsd > 0 ? view2.unhealthyBorrowValueUsd / view2.weightedBorrowValueUsd : Infinity;
+    views.push(view2);
   }
   const walletViews = [];
   for (const { c, cTokens } of wallet) {
@@ -65104,10 +66988,10 @@ async function fetchSaveUser(account, opts = {}) {
     const uid = createMarketUid(SOLANA_CHAIN_ID, lenderKey, c.reserve);
     const s = states[c.reserve];
     const reason = servedReason(c.reserve);
-    const dec = s?.reserve.liquidity.mintDecimals ?? 0;
+    const dec2 = s?.reserve.liquidity.mintDecimals ?? 0;
     const amountStr = s ? scaledToDecimal(
       cTokens * saveExchangeRateWad(s.reserve) / SAVE_WAD,
-      dec
+      dec2
     ) : "0";
     const usd = s ? Number(amountStr) * wadToNumber(s.reserve.liquidity.marketPrice) : 0;
     walletViews.push({
@@ -65163,11 +67047,11 @@ async function fetchSaveUser(account, opts = {}) {
 }
 
 // src/lending/user-data/loopscale/fetchUser.ts
-import { createSvmRpc as createSvmRpc9, getMints as getMints2 } from "@1delta/svm-kit";
+import { createSvmRpc as createSvmRpc10, getMints as getMints2 } from "@1delta/svm-kit";
 var shortAddr = (a) => `${a.slice(0, 4)}\u2026${a.slice(-4)}`;
 function convertLoopscaleUser(account, items, opts) {
   const now = opts.now ?? Math.floor(Date.now() / 1e3);
-  const dec = (mint) => opts.decimals[mint];
+  const dec2 = (mint) => opts.decimals[mint];
   const positions = {};
   const loans = [];
   const skipped = [];
@@ -65178,7 +67062,7 @@ function convertLoopscaleUser(account, items, opts) {
       ...it.ledgers.map((l) => l.principalMint),
       ...it.collateral.map((c) => c.assetMint)
     ]);
-    const missing = [...mints].filter((m) => dec(m) === void 0);
+    const missing = [...mints].filter((m) => dec2(m) === void 0);
     if (missing.length) {
       if (!it.loan.closed)
         skipped.push({
@@ -65187,7 +67071,7 @@ function convertLoopscaleUser(account, items, opts) {
         });
       continue;
     }
-    const tok = (raw2, mint) => raw2 / 10 ** dec(mint);
+    const tok = (raw2, mint) => raw2 / 10 ** dec2(mint);
     const ledgers = it.ledgers.map((l) => {
       const d2 = { duration: l.duration, durationType: l.durationType };
       const toMaturity = ledgerInterestAt(
@@ -65361,7 +67245,7 @@ async function fetchLoopscaleUser(account, opts = {}) {
   ];
   if (unknown.length) {
     try {
-      const mints = await getMints2(opts.rpc ?? createSvmRpc9(), unknown);
+      const mints = await getMints2(opts.rpc ?? createSvmRpc10(), unknown);
       mints.forEach((m, i) => {
         if (m) decimals[unknown[i]] = m.decimals;
       });
@@ -65382,12 +67266,12 @@ async function fetchLoopscaleUser(account, opts = {}) {
 // src/lending/user-data/project0/fetchUser.ts
 import {
   createSvmFetchers as createSvmFetchers3,
-  createSvmRpc as createSvmRpc10,
+  createSvmRpc as createSvmRpc11,
   encodeBase58 as encodeBase589
 } from "@1delta/svm-kit";
 var flagOn = (flags, bit) => (BigInt(flags) & bit) !== 0n;
 async function fetchProject0User(account, opts = {}) {
-  const rpc = opts.rpc ?? createSvmRpc10();
+  const rpc = opts.rpc ?? createSvmRpc11();
   const groups = opts.groups?.length ? opts.groups : [P0_MAIN_GROUP];
   const pub = opts.publicData ?? await fetchProject0Public({ ...opts, rpc, groups });
   const found = [];
@@ -65495,7 +67379,7 @@ async function fetchProject0User(account, opts = {}) {
     }).catch(() => void 0) === acc.address;
     const label = isPda ? `#${acc.accountIndex}${acc.thirdPartyIndex ? ` \xB7 third party ${acc.thirdPartyIndex}` : ""}` : `keypair ${acc.address.slice(0, 4)}\u2026${acc.address.slice(-4)}`;
     const emodeActive = /* @__PURE__ */ new Set();
-    const view = {
+    const view2 = {
       address: acc.address,
       group,
       lenderKey,
@@ -65527,7 +67411,7 @@ async function fetchProject0User(account, opts = {}) {
     for (const b of active) {
       const hit = rowsByBank.get(b.bank);
       if (!hit) {
-        view.incomplete = true;
+        view2.incomplete = true;
         unserved.push({
           account: acc.address,
           bank: b.bank,
@@ -65536,7 +67420,7 @@ async function fetchProject0User(account, opts = {}) {
           liabilityShares: b.liabilityShares,
           reason: !bundle ? "group not served" : meta?.droppedBanks.find((d2) => d2.bank === b.bank)?.reason ?? "not in the group roster"
         });
-        view.balances.push({
+        view2.balances.push({
           bank: b.bank,
           mint: meta?.banks[b.bank]?.mint ?? "",
           symbol: meta?.banks[b.bank]?.symbol ?? b.bank.slice(0, 4),
@@ -65580,7 +67464,7 @@ async function fetchProject0User(account, opts = {}) {
       const lwMaint = p0.liabilityWeightMaint;
       const depUsd = deposited * price;
       const borUsd = borrowed * price;
-      view.balances.push({
+      view2.balances.push({
         bank: b.bank,
         marketUid: uid,
         mint: row.underlying,
@@ -65599,10 +67483,10 @@ async function fetchProject0User(account, opts = {}) {
         emissionsOutstanding: b.emissionsOutstanding,
         unpriced: p0.price.source === "none"
       });
-      view.assetValueInitUsd += depUsd * awInit;
-      view.assetValueMaintUsd += depUsd * awMaint;
-      view.liabilityValueInitUsd += borUsd * lwInit;
-      view.liabilityValueMaintUsd += borUsd * lwMaint;
+      view2.assetValueInitUsd += depUsd * awInit;
+      view2.assetValueMaintUsd += depUsd * awMaint;
+      view2.liabilityValueInitUsd += borUsd * lwInit;
+      view2.liabilityValueMaintUsd += borUsd * lwMaint;
       legs[uid] = {
         marketUid: uid,
         deposits: p0DecimalString(deposited, row.decimals),
@@ -65616,13 +67500,13 @@ async function fetchProject0User(account, opts = {}) {
         claimableRewards: 0
       };
     }
-    view.healthFactor = view.liabilityValueMaintUsd > 0 ? view.assetValueMaintUsd / view.liabilityValueMaintUsd : Infinity;
-    view.freeCollateralUsd = Math.max(
+    view2.healthFactor = view2.liabilityValueMaintUsd > 0 ? view2.assetValueMaintUsd / view2.liabilityValueMaintUsd : Infinity;
+    view2.freeCollateralUsd = Math.max(
       0,
-      view.assetValueInitUsd - view.liabilityValueInitUsd
+      view2.assetValueInitUsd - view2.liabilityValueInitUsd
     );
-    view.emodeActive = [...emodeActive];
-    views.push(view);
+    view2.emodeActive = [...emodeActive];
+    views.push(view2);
     if (!active.length) continue;
     const out = positions[lenderKey] ??= {
       chainId: SOLANA_CHAIN_ID,
@@ -65855,7 +67739,7 @@ function kaminoTermAdapter(row, market) {
   if (row.originationFee === void 0)
     pending["borrow.fees"] = "origination and flash-loan fees are in the reserve account, which was not read";
   for (const p of market?.pending ?? []) pending[`market: ${p}`] = p;
-  const liq = market?.liquidation;
+  const liq2 = market?.liquidation;
   return {
     profileId: KAMINO_PROFILE_ID,
     borrow: {
@@ -65929,14 +67813,14 @@ function kaminoTermAdapter(row, market) {
         debtWithdrawalCap: capExt(k.debtWithdrawalCap),
         // remaining new debt outside any elevation group (`borrowLimitOutsideElevationGroup − tracked`)
         debtCapacityOutsideGroups: base.debtCapacity,
-        ...liq ? {
+        ...liq2 ? {
           fullLiquidation: {
             // obligation LTV above which the close factor is 100 %
-            aboveLtv: liq.insolvencyRiskUnhealthyLtvPct / 100,
+            aboveLtv: liq2.insolvencyRiskUnhealthyLtvPct / 100,
             // a debt leg worth less than this is liquidated whole
-            belowDebtValueUsd: liq.minFullLiquidationValueThresholdUsd,
+            belowDebtValueUsd: liq2.minFullLiquidationValueThresholdUsd,
             // one liquidation repays at most this
-            maxPerLiquidationUsd: liq.maxLiquidatableDebtMarketValueAtOnceUsd
+            maxPerLiquidationUsd: liq2.maxLiquidatableDebtMarketValueAtOnceUsd
           }
         } : {},
         ...k.pairIncentives.length ? { pairIncentives: k.pairIncentives } : {}
@@ -66801,9 +68685,12 @@ export {
   HUMA_SEEDS,
   HttpError,
   JL_BPS,
+  JL_EXCHANGE_PRICES_PRECISION,
   JL_FACTOR_SCALE,
   JL_ORACLE_DECIMALS,
   JL_ORACLE_SCALE,
+  JL_VAULTS_ACCOUNTS_IDL,
+  JL_VAULT_AMOUNT_DECIMALS,
   JUPITER_LEND_API_BASE,
   JUPITER_LEND_KEYED_API_BASE,
   JUPITER_LEND_KEY_PREFIX,
@@ -66812,9 +68699,11 @@ export {
   JUPITER_LEND_PROGRAMS,
   JUPITER_PRICE_API_BASE,
   JUPITER_PRICE_KEYED_API_BASE,
+  JUP_DEX_PROGRAM,
   JUP_FLASHLOAN_IDL,
   JUP_FLASHLOAN_PROGRAMS,
   JUP_LIQUIDITY_PROGRAMS,
+  JUP_VAULTS_PROGRAMS,
   KAMINO_API_BASE,
   KAMINO_KEY_PREFIX,
   KAMINO_MAIN_MARKET,
@@ -66834,6 +68723,7 @@ export {
   KLEND_RESERVE_SIZE,
   KLEND_RESERVE_SLICE,
   KLEND_U64_MAX,
+  KVAULT_PROGRAM_ID,
   LENDER_BRAND_NAMES,
   LOANS_PAGE,
   LOOPSCALE_ACCOUNT_DISCRIMINATORS,
@@ -66921,7 +68811,7 @@ export {
   SAVE_UNBORROWABLE_BORROW_FACTOR,
   SAVE_WAD,
   SAVE_WALLET_POS_ID,
-  SECONDS_PER_YEAR,
+  SECONDS_PER_YEAR2 as SECONDS_PER_YEAR,
   SETTLEMENT_BATCH_SIZE,
   SOLANA_CHAIN_ID,
   SOLSTICE_APP_API_BASE,
@@ -66964,6 +68854,7 @@ export {
   convertJupiterLendOracleEntries,
   convertJupiterLendUserPositions,
   convertJupiterLendVault,
+  convertKaminoKvault,
   convertKaminoLoans,
   convertKaminoMarket,
   convertKaminoOraclePrices,
@@ -66980,6 +68871,7 @@ export {
   createExponentApi,
   createJupiterLendApi,
   createKaminoApi,
+  createKaminoKvaultApi,
   createLimiter,
   createLoopscaleApi,
   createMarketUid,
@@ -66989,6 +68881,7 @@ export {
   createSolsticeAppApi,
   createWithSeed,
   decimalStringToI80F48,
+  decimalStringToRaw,
   decodeAccountingState,
   decodeController,
   decodeCooldownEscrow,
@@ -67041,6 +68934,7 @@ export {
   fetchJupiterLendPublic,
   fetchJupiterLendUser,
   fetchJupiterPrices,
+  fetchKaminoKvaults,
   fetchKaminoOracleEntries,
   fetchKaminoOraclePrices,
   fetchKaminoPublic,
@@ -67083,6 +68977,8 @@ export {
   i80f48ToNumber,
   isBorrowable,
   isEvmChainId,
+  isJlSmartCol,
+  isJlSmartDebt,
   isJupiterLend,
   isKamino,
   isLenderBrand,
@@ -67102,8 +68998,17 @@ export {
   isSyntheticQuoteMint,
   isU64Max,
   isUncapped,
+  jlLiquidityExchangePrices,
   jlOraclePriceInBorrow,
   jlOracleToFluidRaw,
+  jlOverallTokenData,
+  jlUserBorrowData,
+  jlUserSupplyData,
+  jlVaultAdminPda,
+  jlVaultConfigPda,
+  jlVaultExchangePrices,
+  jlVaultStatePda,
+  jlVaultToRaw,
   joinableBatch,
   juniorUnlockSharePda,
   jupFlashBorrowPosition,
@@ -67122,6 +69027,7 @@ export {
   kaminoCloseFactor,
   kaminoDefaultEntry,
   kaminoGroupLabel,
+  kaminoKvaultOriginRow,
   kaminoMarketFromKey,
   kaminoMarketKey,
   kaminoOracleEntriesFromMarkets,
@@ -67183,9 +69089,11 @@ export {
   readHumaChainState,
   readHumaLenderState,
   readHumaRedemptionRequests,
+  readJlNextVaultId,
   readJupFlashAssets,
   readJupFlashAvailable,
   readJupFlashloanAdmin,
+  readJupiterLendVaultsOnchain,
   readKlendElevationGroups,
   readKlendFlashFacts,
   readKlendLendingMarket,