@pyron-finance/pyron-client 2.9.5 → 2.10.0

package/dist/index.js

@@ -462,7 +462,7 @@ import {
   TransactionMessage as TransactionMessage6,
   VersionedTransaction as VersionedTransaction6
 } from "@solana/web3.js";
-import BigNumber16 from "bignumber.js";
+import BigNumber17 from "bignumber.js";
 import bs582 from "bs58";
 import { createStorage } from "unstorage";
 
@@ -13974,7 +13974,7 @@ import {
   TOKEN_2022_PROGRAM_ID
 } from "@solana/spl-token";
 import { ComputeBudgetProgram as ComputeBudgetProgram5, PublicKey as PublicKey27 } from "@solana/web3.js";
-import BigNumber14 from "bignumber.js";
+import BigNumber15 from "bignumber.js";
 import BN13 from "bn.js";
 
 // src/services/account/account.service.ts
@@ -13986,7 +13986,7 @@ import {
   TransactionMessage as TransactionMessage4,
   VersionedTransaction as VersionedTransaction4
 } from "@solana/web3.js";
-import BigNumber12 from "bignumber.js";
+import BigNumber14 from "bignumber.js";
 import BN11 from "bn.js";
 
 // src/models/health-cache.ts
@@ -24971,1168 +24971,1229 @@ function dtoToHealthCache(healthCacheDto) {
 }
 
 // src/services/account/utils/emode.utils.ts
-function computeEmodeImpacts(emodePairs, activeLiabilities, activeCollateral, allBanks) {
-  const toKey = (k) => k.toBase58();
-  const basePairs = computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral);
-  const baseOn = basePairs.length > 0;
-  const liabTagMap = /* @__PURE__ */ new Map();
-  for (const p of emodePairs) {
-    liabTagMap.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
-  }
-  const existingTags = new Set(
-    activeLiabilities.map((l) => liabTagMap.get(l.toBase58())).filter((t) => !!t)
-  );
-  function minWeight(ps) {
-    let m = ps[0].assetWeightInit;
-    for (const x of ps) if (x.assetWeightInit.lt(m)) m = x.assetWeightInit;
-    return m;
-  }
-  function diffState(before, after) {
-    const was = before.length > 0, isOn = after.length > 0;
-    if (!was && !isOn) return 5 /* InactiveEmode */;
-    if (!was && isOn) return 0 /* ActivateEmode */;
-    if (was && !isOn) return 4 /* RemoveEmode */;
-    const bMin = minWeight(before), aMin = minWeight(after);
-    if (aMin.gt(bMin)) return 2 /* IncreaseEmode */;
-    if (aMin.lt(bMin)) return 3 /* ReduceEmode */;
-    return 1 /* ExtendEmode */;
-  }
-  function simulate(bank, action) {
-    let L = [...activeLiabilities], C = [...activeCollateral];
-    switch (action) {
-      case "borrow":
-        if (!L.some((x) => x.equals(bank))) L.push(bank);
-        break;
-      case "repay":
-        L = L.filter((x) => !x.equals(bank));
-        break;
-      case "supply":
-        if (!C.some((x) => x.equals(bank))) C.push(bank);
-        break;
-      case "withdraw":
-        C = C.filter((x) => !x.equals(bank));
-        break;
-    }
-    const after = computeActiveEmodePairs(emodePairs, L, C);
-    let status = diffState(basePairs, after);
-    if (action === "borrow") {
-      const tag = liabTagMap.get(bank.toBase58());
-      if (!tag) {
-        status = baseOn ? 4 /* RemoveEmode */ : 5 /* InactiveEmode */;
-      } else if (baseOn) {
-        if (after.length === 0) {
-          status = 4 /* RemoveEmode */;
-        } else if (existingTags.has(tag)) {
-          status = 1 /* ExtendEmode */;
-        }
-      }
-    }
-    if (action === "supply") {
-      const isOn = after.length > 0;
-      status = !baseOn && isOn ? 0 /* ActivateEmode */ : baseOn && isOn ? 1 /* ExtendEmode */ : 5 /* InactiveEmode */;
-    }
-    if (action === "withdraw") {
-      if (!baseOn) {
-        status = 5 /* InactiveEmode */;
-      } else if (after.length === 0) {
-        status = 4 /* RemoveEmode */;
-      } else {
-        const b = minWeight(basePairs), a = minWeight(after);
-        if (a.gt(b)) status = 2 /* IncreaseEmode */;
-        else if (a.lt(b)) status = 3 /* ReduceEmode */;
-        else status = 1 /* ExtendEmode */;
-      }
-    }
-    let bestPair;
-    if (after.length > 0) {
-      bestPair = after[0];
-      for (const p of after) {
-        if (p.assetWeightInit.lt(bestPair.assetWeightInit)) {
-          bestPair = p;
-        }
-      }
-    }
-    const activeEmodePair = bestPair ? {
-      collateralBanks: Array.from(
-        new Map(after.flatMap((p) => p.collateralBanks).map((bank2) => [bank2.toBase58(), bank2])).values()
-      ),
-      collateralBankTags: Array.from(new Set(after.flatMap((p) => p.collateralBankTag))),
-      liabilityBanks: Array.from(
-        new Map(after.flatMap((p) => p.liabilityBank).map((bank2) => [bank2.toBase58(), bank2])).values()
-      ),
-      liabilityBankTags: Array.from(new Set(after.flatMap((p) => p.liabilityBankTag))),
-      assetWeightMaint: bestPair.assetWeightMaint,
-      assetWeightInit: bestPair.assetWeightInit
-    } : void 0;
-    return {
-      status,
-      resultingPairs: after,
-      activePair: activeEmodePair
-    };
-  }
-  const result = {};
-  for (const bank of allBanks) {
-    const key = toKey(bank);
-    const impact = {};
-    if (!activeCollateral.some((x) => x.equals(bank))) {
-      impact.borrowImpact = simulate(bank, "borrow");
-    }
-    const collSet = new Set(emodePairs.flatMap((p) => p.collateralBanks.map((c) => c.toBase58())));
-    if (collSet.has(key) && !activeCollateral.some((x) => x.equals(bank)) && !activeLiabilities.some((x) => x.equals(bank))) {
-      impact.supplyImpact = simulate(bank, "supply");
-    }
-    if (activeLiabilities.some((x) => x.equals(bank))) {
-      impact.repayAllImpact = simulate(bank, "repay");
-    }
-    if (activeCollateral.some((x) => x.equals(bank))) {
-      impact.withdrawAllImpact = simulate(bank, "withdraw");
-    }
-    result[key] = impact;
+import BigNumber13 from "bignumber.js";
+
+// src/models/bank.ts
+import BigNumber12 from "bignumber.js";
+var SECONDS_PER_DAY2 = 24 * 60 * 60;
+var _SECONDS_PER_YEAR = SECONDS_PER_DAY2 * 365.25;
+var Bank = class _Bank {
+  constructor(address, mint, mintDecimals, group, mintRate, mintPrice, assetShareValue, liabilityShareValue, liquidityVault, liquidityVaultBump, liquidityVaultAuthorityBump, insuranceVault, insuranceVaultBump, insuranceVaultAuthorityBump, collectedInsuranceFeesOutstanding, feeVault, feeVaultBump, feeVaultAuthorityBump, collectedGroupFeesOutstanding, lastUpdate, config, totalAssetShares, totalLiabilityShares, flags, emissionsActiveBorrowing, emissionsActiveLending, emissionsRate, emissionsMint, emissionsRemaining, oracleKey, emode, feesDestinationAccount, lendingPositionCount, borrowingPositionCount, pythShardId, tokenSymbol, extendedMetadata, owner) {
+    this.address = address;
+    this.mint = mint;
+    this.mintDecimals = mintDecimals;
+    this.group = group;
+    this.mintRate = mintRate;
+    this.mintPrice = mintPrice;
+    this.assetShareValue = assetShareValue;
+    this.liabilityShareValue = liabilityShareValue;
+    this.liquidityVault = liquidityVault;
+    this.liquidityVaultBump = liquidityVaultBump;
+    this.liquidityVaultAuthorityBump = liquidityVaultAuthorityBump;
+    this.insuranceVault = insuranceVault;
+    this.insuranceVaultBump = insuranceVaultBump;
+    this.insuranceVaultAuthorityBump = insuranceVaultAuthorityBump;
+    this.collectedInsuranceFeesOutstanding = collectedInsuranceFeesOutstanding;
+    this.feeVault = feeVault;
+    this.feeVaultBump = feeVaultBump;
+    this.feeVaultAuthorityBump = feeVaultAuthorityBump;
+    this.collectedGroupFeesOutstanding = collectedGroupFeesOutstanding;
+    this.lastUpdate = lastUpdate;
+    this.config = config;
+    this.totalAssetShares = totalAssetShares;
+    this.totalLiabilityShares = totalLiabilityShares;
+    this.flags = flags;
+    this.emissionsActiveBorrowing = emissionsActiveBorrowing;
+    this.emissionsActiveLending = emissionsActiveLending;
+    this.emissionsRate = emissionsRate;
+    this.emissionsMint = emissionsMint;
+    this.emissionsRemaining = emissionsRemaining;
+    this.oracleKey = oracleKey;
+    this.emode = emode;
+    this.feesDestinationAccount = feesDestinationAccount;
+    this.lendingPositionCount = lendingPositionCount;
+    this.borrowingPositionCount = borrowingPositionCount;
+    this.pythShardId = pythShardId;
+    this.tokenSymbol = tokenSymbol;
+    this.extendedMetadata = extendedMetadata;
+    this.owner = owner;
   }
-  return result;
-}
-function computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral) {
-  const configured = emodePairs.filter(
-    (p) => p.collateralBankTag !== EmodeTag.UNSET && p.liabilityBankTag !== EmodeTag.UNSET
-  );
-  const liabTagByBank = /* @__PURE__ */ new Map();
-  for (const p of configured) {
-    liabTagByBank.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
+  static decodeBankRaw(encoded, idl) {
+    return decodeBankRaw(encoded, idl);
   }
-  const requiredTags = /* @__PURE__ */ new Set();
-  for (const liab of activeLiabilities) {
-    const tag = liabTagByBank.get(liab.toBase58());
-    if (!tag) {
-      return [];
-    }
-    requiredTags.add(tag);
+  static fromBuffer(bankPk, rawData, idl, feedIdMap) {
+    const accountParsed = _Bank.decodeBankRaw(rawData, idl);
+    return _Bank.fromAccountParsed(bankPk, accountParsed, feedIdMap);
   }
-  const possible = configured.filter(
-    (p) => activeLiabilities.some((l) => l.equals(p.liabilityBank)) && p.collateralBanks.some((c) => activeCollateral.some((a) => a.equals(c)))
-  );
-  if (possible.length === 0) return [];
-  const byCollTag = {};
-  for (const p of possible) {
-    const ct = p.collateralBankTag.toString();
-    if (!byCollTag[ct]) {
-      byCollTag[ct] = [];
-    }
-    byCollTag[ct].push(p);
+  static fromBankType(bankType) {
+    const config = new BankConfig(
+      bankType.config.assetWeightInit,
+      bankType.config.assetWeightMaint,
+      bankType.config.liabilityWeightInit,
+      bankType.config.liabilityWeightMaint,
+      bankType.config.depositLimit,
+      bankType.config.borrowLimit,
+      bankType.config.riskTier,
+      bankType.config.totalAssetValueInitLimit,
+      bankType.config.assetTag,
+      bankType.config.oracleSetup,
+      bankType.config.oracleKeys,
+      bankType.config.oracleMaxAge,
+      bankType.config.interestRateConfig,
+      bankType.config.operationalState,
+      bankType.config.oracleMaxConfidence,
+      bankType.config.fixedPrice,
+      bankType.config.configFlags
+    );
+    return new _Bank(
+      bankType.address,
+      bankType.mint,
+      bankType.mintDecimals,
+      bankType.group,
+      bankType.mintRate,
+      bankType.mintPrice,
+      bankType.assetShareValue,
+      bankType.liabilityShareValue,
+      bankType.liquidityVault,
+      bankType.liquidityVaultBump,
+      bankType.liquidityVaultAuthorityBump,
+      bankType.insuranceVault,
+      bankType.insuranceVaultBump,
+      bankType.insuranceVaultAuthorityBump,
+      bankType.collectedInsuranceFeesOutstanding,
+      bankType.feeVault,
+      bankType.feeVaultBump,
+      bankType.feeVaultAuthorityBump,
+      bankType.collectedGroupFeesOutstanding,
+      bankType.lastUpdate,
+      config,
+      bankType.totalAssetShares,
+      bankType.totalLiabilityShares,
+      bankType.flags,
+      bankType.emissionsActiveBorrowing,
+      bankType.emissionsActiveLending,
+      bankType.emissionsRate,
+      bankType.emissionsMint,
+      bankType.emissionsRemaining,
+      bankType.oracleKey,
+      bankType.emode,
+      bankType.feesDestinationAccount,
+      bankType.lendingPositionCount,
+      bankType.borrowingPositionCount,
+      bankType.pythShardId,
+      bankType.tokenSymbol
+    );
   }
-  const validGroups = [];
-  for (const group of Object.values(byCollTag)) {
-    const supports = new Set(group.map((p) => p.liabilityBankTag.toString()));
-    let coversAll = true;
-    for (const rt of requiredTags) {
-      if (!supports.has(rt)) {
-        coversAll = false;
-        break;
-      }
-    }
-    if (coversAll) {
-      validGroups.push(group);
-    }
+  static fromAccountParsed(address, accountParsed, feedIdMap, extendedMetadata, owner) {
+    const props = parseBankRaw(address, accountParsed, feedIdMap);
+    return new _Bank(
+      props.address,
+      props.mint,
+      props.mintDecimals,
+      props.group,
+      props.mintRate,
+      props.mintPrice,
+      props.assetShareValue,
+      props.liabilityShareValue,
+      props.liquidityVault,
+      props.liquidityVaultBump,
+      props.liquidityVaultAuthorityBump,
+      props.insuranceVault,
+      props.insuranceVaultBump,
+      props.insuranceVaultAuthorityBump,
+      props.collectedInsuranceFeesOutstanding,
+      props.feeVault,
+      props.feeVaultBump,
+      props.feeVaultAuthorityBump,
+      props.collectedGroupFeesOutstanding,
+      props.lastUpdate,
+      props.config,
+      props.totalAssetShares,
+      props.totalLiabilityShares,
+      props.flags,
+      props.emissionsActiveBorrowing,
+      props.emissionsActiveLending,
+      props.emissionsRate,
+      props.emissionsMint,
+      props.emissionsRemaining,
+      props.oracleKey,
+      props.emode,
+      props.feesDestinationAccount,
+      props.lendingPositionCount,
+      props.borrowingPositionCount,
+      props.pythShardId,
+      extendedMetadata?.symbol,
+      extendedMetadata,
+      owner
+    );
   }
-  if (validGroups.length === 0) return [];
-  return validGroups.flat();
-}
-
-// src/services/account/utils/fetch.utils.ts
-var fetchLendrAccountAddresses = async (program, authority, group) => {
-  const lendrAccounts = (await program.account.lendrAccount.all([
-    {
-      memcmp: {
-        bytes: group.toBase58(),
-        offset: 8
-        // lendrGroup is the first field in the account, so only offset is the discriminant
-      }
-    },
-    {
-      memcmp: {
-        bytes: authority.toBase58(),
-        offset: 8 + 32
-        // authority is the second field in the account after the authority, so offset by the discriminant and a pubkey
-      }
-    }
-  ])).map((a) => a.publicKey);
-  return lendrAccounts;
-};
-var fetchLendrAccountData = async (program, lendrAccountPk, bankMap, oraclePrices, bankMetadataMap) => {
-  const lendrAccountRaw = await program.account.lendrAccount.fetch(lendrAccountPk, "confirmed");
-  const lendrAccount = LendrAccount.fromAccountParsed(lendrAccountPk, lendrAccountRaw);
-  const lendrAccountWithCache = await simulateAccountHealthCacheWithFallback({
-    program,
-    lendrAccount,
-    bankMap,
-    oraclePrices,
-    bankMetadataMap,
-    balances: lendrAccount.balances
-  });
-  return lendrAccountWithCache;
-};
-
-// src/services/account/utils/serialize.utils.ts
-import BN10 from "bn.js";
-function accountFlagToBN(flag) {
-  return new BN10(flag);
-}
-function lendrAccountToDto(lendrAccount) {
-  return {
-    address: lendrAccount.address.toBase58(),
-    group: lendrAccount.group.toBase58(),
-    authority: lendrAccount.authority.toBase58(),
-    balances: lendrAccount.balances.map(balanceToDto),
-    accountFlags: lendrAccount.accountFlags,
-    emissionsDestinationAccount: lendrAccount.emissionsDestinationAccount.toBase58(),
-    healthCache: healthCacheToDto(lendrAccount.healthCache)
-  };
-}
-function balanceToDto(balance) {
-  return {
-    active: balance.active,
-    bankPk: balance.bankPk.toBase58(),
-    assetShares: balance.assetShares.toString(),
-    liabilityShares: balance.liabilityShares.toString(),
-    emissionsOutstanding: balance.emissionsOutstanding.toString(),
-    lastUpdate: balance.lastUpdate
-  };
-}
-function healthCacheToDto(healthCache) {
-  return {
-    assetValue: healthCache.assetValue.toString(),
-    liabilityValue: healthCache.liabilityValue.toString(),
-    assetValueMaint: healthCache.assetValueMaint.toString(),
-    liabilityValueMaint: healthCache.liabilityValueMaint.toString(),
-    assetValueEquity: healthCache.assetValueEquity.toString(),
-    liabilityValueEquity: healthCache.liabilityValueEquity.toString(),
-    timestamp: healthCache.timestamp.toString(),
-    flags: healthCache.flags,
-    prices: healthCache.prices,
-    simulationFailed: healthCache.simulationFailed
-  };
-}
-
-// src/services/account/account.service.ts
-var HealthCacheSimulationError = class _HealthCacheSimulationError extends Error {
-  lndrErr;
-  internalErr;
-  constructor(message, lndrErr, internalErr) {
-    super(message);
-    this.name = "HealthCacheSimulationError";
-    this.lndrErr = lndrErr;
-    this.internalErr = internalErr;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _HealthCacheSimulationError);
-    }
+  static withEmodeWeights(bank, emodeWeights) {
+    const newBank = Object.create(_Bank.prototype);
+    Object.assign(newBank, bank);
+    newBank.config = Object.assign({}, bank.config);
+    newBank.config.assetWeightInit = BigNumber12.max(bank.config.assetWeightInit, emodeWeights.assetWeightInit);
+    newBank.config.assetWeightMaint = BigNumber12.max(bank.config.assetWeightMaint, emodeWeights.assetWeightMaint);
+    return newBank;
   }
-};
-async function simulateAccountHealthCacheWithFallback(props) {
-  let lendrAccount = props.lendrAccount;
-  const activeBalances = props.balances.filter((b) => b.active);
-  const { assets: assetValueEquity, liabilities: liabilityValueEquity } = computeHealthComponentsWithoutBiasLegacy(
-    activeBalances,
-    props.bankMap,
-    props.oraclePrices,
-    2 /* Equity */
-  );
-  try {
-    const simulatedAccount = await simulateAccountHealthCache({
-      program: props.program,
-      bankMap: props.bankMap,
-      oraclePrices: props.oraclePrices,
-      lendrAccountPk: props.lendrAccount.address,
-      balances: props.balances,
-      bankMetadataMap: props.bankMetadataMap
-    });
-    simulatedAccount.healthCache.assetValueEquity = bigNumberToWrappedI80F48(assetValueEquity);
-    simulatedAccount.healthCache.liabilityValueEquity = bigNumberToWrappedI80F48(liabilityValueEquity);
-    lendrAccount = LendrAccount.fromAccountParsed(props.lendrAccount.address, simulatedAccount);
-  } catch (e) {
-    console.log("e", e);
-    const { assets: assetValueMaint, liabilities: liabilityValueMaint } = computeHealthComponentsLegacy(
-      activeBalances,
-      props.bankMap,
-      props.oraclePrices,
-      1 /* Maintenance */
-    );
-    const { assets: assetValueInitial, liabilities: liabilityValueInitial } = computeHealthComponentsLegacy(
-      activeBalances,
-      props.bankMap,
-      props.oraclePrices,
-      0 /* Initial */
-    );
-    lendrAccount.setHealthCache(
-      new HealthCache(
-        assetValueInitial,
-        liabilityValueInitial,
-        assetValueMaint,
-        liabilityValueMaint,
-        assetValueEquity,
-        liabilityValueEquity,
-        new BigNumber12(0),
-        [],
-        [],
-        true
-      )
-    );
-    if (e instanceof HealthCacheSimulationError) {
-      return { lendrAccount, error: e };
-    }
+  static getPrice(oraclePrice, priceBias = 1 /* None */, weightedPrice = false) {
+    return getPrice(oraclePrice, priceBias, weightedPrice);
   }
-  return { lendrAccount };
-}
-async function simulateAccountHealthCache(props) {
-  const { program, bankMap, oraclePrices, lendrAccountPk, balances, bankMetadataMap } = props;
-  const activeBalances = balances.filter((b) => b.active);
-  const { staleSwbOracles } = getActiveStaleBanks(activeBalances, bankMap, [], oraclePrices, 30);
-  const computeIx = ComputeBudgetProgram4.setComputeUnitLimit({ units: 14e5 });
-  const blockhash = (await program.provider.connection.getLatestBlockhash("confirmed")).blockhash;
-  const fundAccountIx = SystemProgram3.transfer({
-    fromPubkey: new PublicKey22("DD3AeAssFvjqTvRTrRAtpfjkBF8FpVKnFuwnMLN9haXD"),
-    // lendr SOL VAULT
-    toPubkey: program.provider.publicKey,
-    lamports: 1e8
-    // 0.1 SOL
-  });
-  const crankPythIxs = {
-    postInstructions: [],
-    closeInstructions: [],
-    keys: [],
-    lut: null
-  };
-  const crankSwbIxs = staleSwbOracles.length > 0 ? await createUpdateFeedIx({
-    swbPullOracles: staleSwbOracles.map((oracle) => oracle.oracleKey),
-    provider: program.provider
-  }) : { instructions: [], luts: [] };
-  const healthPulseIxs = await makePulseHealthIx2(
-    program,
-    lendrAccountPk,
-    bankMap,
-    balances,
-    activeBalances.map((b) => b.bankPk),
-    [],
-    bankMetadataMap
-  );
-  const pythLut = crankPythIxs.lut ? [crankPythIxs.lut] : [];
-  const txs = [];
-  if (crankPythIxs.postInstructions.length > 0) {
-    txs.push(
-      ...splitInstructionsToFitTransactions(
-        [computeIx],
-        [
-          fundAccountIx,
-          ...crankPythIxs.postInstructions.map((ix) => ix.instruction),
-          ...crankPythIxs.closeInstructions.map((ix) => ix.instruction)
-        ],
-        {
-          blockhash,
-          payerKey: program.provider.publicKey,
-          luts: [...crankSwbIxs.luts, ...pythLut]
-        }
-      )
-    );
+  static computeQuantityFromUsdValue(oraclePrice, usdValue, priceBias, weightedPrice) {
+    const price = getPrice(oraclePrice, priceBias, weightedPrice);
+    return usdValue.div(price);
   }
-  const messageV0 = new TransactionMessage4({
-    payerKey: program.provider.publicKey,
-    recentBlockhash: blockhash,
-    instructions: [...crankSwbIxs.instructions]
-  }).compileToV0Message([...crankSwbIxs.luts]);
-  const swbTx = new VersionedTransaction4(messageV0);
-  txs.push(swbTx);
-  const healthTx = new TransactionMessage4({
-    payerKey: program.provider.publicKey,
-    recentBlockhash: blockhash,
-    instructions: [...healthPulseIxs.instructions]
-  }).compileToV0Message([]);
-  const healthTxV0 = new VersionedTransaction4(healthTx);
-  txs.push(healthTxV0);
-  if (txs.length > 5) {
-    console.error("Too many transactions", txs.length);
-    throw new Error("Too many transactions");
+  getTotalAssetQuantity() {
+    return getTotalAssetQuantity(this);
   }
-  const simulationResult = await simulateBundle(program.provider.connection.rpcEndpoint, txs, [lendrAccountPk]);
-  const postExecutionAccount = simulationResult.find((result) => result.postExecutionAccounts.length > 0);
-  if (!postExecutionAccount) {
-    throw new Error("Account not found");
+  getTotalLiabilityQuantity() {
+    return getTotalLiabilityQuantity(this);
   }
-  const lendrAccountPost = LendrAccount.decodeAccountRaw(
-    Buffer.from(postExecutionAccount.postExecutionAccounts[0].data[0], "base64"),
-    program.idl
-  );
-  if (lendrAccountPost.healthCache.lndrErr || lendrAccountPost.healthCache.internalErr) {
-    console.log(
-      "cranked swb oracles",
-      staleSwbOracles.map((oracle) => oracle.oracleKey)
-    );
-    console.log("LendrAccountPost healthCache internalErr", lendrAccountPost.healthCache.internalErr);
-    console.log("LendrAccountPost healthCache lndrErr", lendrAccountPost.healthCache.lndrErr);
-    if (lendrAccountPost.healthCache.lndrErr === 6009) {
-      const assetValue = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValue).isZero();
-      const liabilityValue = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.liabilityValue).isZero();
-      const assetValueEquity = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValueEquity).isZero();
-      const liabilityValueEquity = !wrappedI80F48toBigNumber(
-        lendrAccountPost.healthCache.liabilityValueEquity
-      ).isZero();
-      const assetValueMaint = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValueMaint).isZero();
-      const liabilityValueMaint = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.liabilityValueMaint).isZero();
-      if (assetValue && liabilityValue && assetValueEquity && liabilityValueEquity && assetValueMaint && liabilityValueMaint) {
-        return lendrAccountPost;
-      }
-    }
-    console.error("Account health cache simulation failed", {
-      lndrErr: lendrAccountPost.healthCache.lndrErr,
-      internalErr: lendrAccountPost.healthCache.internalErr
-    });
-    throw new HealthCacheSimulationError(
-      "Account health cache simulation failed",
-      lendrAccountPost.healthCache.lndrErr,
-      lendrAccountPost.healthCache.internalErr
-    );
+  getAssetQuantity(assetShares) {
+    return getAssetQuantity(this, assetShares);
   }
-  return lendrAccountPost;
-}
-async function makePulseHealthIx2(program, lendrAccountPk, banks, balances, mandatoryBanks, excludedBanks, bankMetadataMap) {
-  const healthAccounts = computeHealthCheckAccounts(balances, banks, mandatoryBanks, excludedBanks);
-  const accountMetas = computeHealthAccountMetas(healthAccounts, bankMetadataMap);
-  const ix = await instructions_default.makePulseHealthIx(
-    program,
-    {
-      lendrAccount: lendrAccountPk
-    },
-    accountMetas.map((account) => ({ pubkey: account, isSigner: false, isWritable: false }))
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function createUpdateFeedIx(_props) {
-  throw new Error("in terms of switchboard, we have no switchboard");
-}
-async function createLendrAccountTx(props) {
-  const authority = props.lendrAccount?.authority ?? props.lendrClient.provider.publicKey;
-  const lendrAccountKeypair = Keypair2.generate();
-  const dummyWrappedI80F48 = bigNumberToWrappedI80F48(new BigNumber12(0));
-  const dummyBalances = Array(15).fill({
-    active: false,
-    bankPk: new PublicKey22("11111111111111111111111111111111"),
-    assetShares: dummyWrappedI80F48,
-    liabilityShares: dummyWrappedI80F48,
-    emissionsOutstanding: dummyWrappedI80F48,
-    lastUpdate: new BN11(0)
-  });
-  const rawAccount = {
-    group: props.lendrClient.group.address,
-    authority,
-    lendingAccount: { balances: dummyBalances },
-    healthCache: {
-      assetValue: {
-        value: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      liabilityValue: {
-        value: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      timestamp: new BN11(0),
-      flags: 0,
-      prices: [],
-      assetValueMaint: bigNumberToWrappedI80F48(new BigNumber12(0)),
-      liabilityValueMaint: bigNumberToWrappedI80F48(new BigNumber12(0)),
-      assetValueEquity: bigNumberToWrappedI80F48(new BigNumber12(0)),
-      liabilityValueEquity: bigNumberToWrappedI80F48(new BigNumber12(0)),
-      errIndex: 0,
-      internalErr: 0,
-      internalBankruptcyErr: 0,
-      internalLiqErr: 0,
-      lndrErr: 0
-    },
-    emissionsDestinationAccount: new PublicKey22("11111111111111111111111111111111"),
-    accountFlags: new BN11([0, 0, 0])
-  };
-  const account = LendrAccount.fromAccountParsed(lendrAccountKeypair.publicKey, rawAccount);
-  const wrappedAccount = new LendrAccountWrapper(lendrAccountKeypair.publicKey, props.lendrClient, account);
-  return {
-    account: wrappedAccount,
-    tx: await props.lendrClient.createLendrAccountTx({ accountKeypair: lendrAccountKeypair })
-  };
-}
-function getActiveStaleBanks(balances, banks, additionalBanks, oraclePrices, maxAgeOffset = 0) {
-  const activeBanks = balances.filter((balance) => balance.active).map((balance) => banks.get(balance.bankPk.toBase58())).filter((bank) => !!bank);
-  const allBanks = [...activeBanks, ...additionalBanks];
-  const staleBanks = allBanks.filter((bank) => {
-    if (bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "SwitchboardV2" /* SwitchboardV2 */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */) {
-      return true;
-    }
-    const oraclePrice = oraclePrices.get(bank.address.toBase58());
-    const maxAge = bank.config.oracleMaxAge;
-    const currentTime = Math.round(Date.now() / 1e3);
-    const oracleTime = Math.round(oraclePrice?.timestamp ? oraclePrice.timestamp.toNumber() : Date.now());
-    const adjustedMaxAge = Math.max(maxAge - maxAgeOffset, 0);
-    const isStale = currentTime - oracleTime > adjustedMaxAge;
-    return isStale;
-  });
-  if (staleBanks.length > 0) {
-    const stalePythFeeds = [];
-    const staleSwbOracles = [];
-    const seenSwbOracles = /* @__PURE__ */ new Set();
-    const seenPythFeeds = /* @__PURE__ */ new Set();
-    staleBanks.forEach((bank) => {
-      if (bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */) {
-        const key = bank.oracleKey.toBase58();
-        if (!seenSwbOracles.has(key)) {
-          seenSwbOracles.add(key);
-          staleSwbOracles.push({ oracleKey: bank.oracleKey });
-        }
-      } else if (bank.config.oracleSetup === "PythPushOracle" /* PythPushOracle */ || bank.config.oracleSetup === "StakedWithPythPush" /* StakedWithPythPush */ || bank.config.oracleSetup === "KaminoPythPush" /* KaminoPythPush */) {
-        const oraclePrice = oraclePrices.get(bank.address.toBase58());
-        const shardId = oraclePrice?.pythShardId ?? 0;
-        const feedId = bank.config.oracleKeys[0];
-        const feedKey = feedIdToString(feedId);
-        if (!seenPythFeeds.has(feedKey)) {
-          seenPythFeeds.add(feedKey);
-          stalePythFeeds.push({ feedId: feedKey, shardId });
-        }
-      }
+  getLiabilityQuantity(liabilityShares) {
+    return getLiabilityQuantity(this, liabilityShares);
+  }
+  getAssetShares(assetQuantity) {
+    return getAssetShares(this, assetQuantity);
+  }
+  getLiabilityShares(liabilityQuantity) {
+    return getLiabilityShares(this, liabilityQuantity);
+  }
+  computeAssetUsdValue(oraclePrice, assetShares, lendrRequirementType, priceBias) {
+    return computeAssetUsdValue(this, oraclePrice, assetShares, lendrRequirementType, priceBias);
+  }
+  computeLiabilityUsdValue(oraclePrice, liabilityShares, lendrRequirementType, priceBias) {
+    return computeLiabilityUsdValue(this, oraclePrice, liabilityShares, lendrRequirementType, priceBias);
+  }
+  computeUsdValue(oraclePrice, quantity, priceBias, weightedPrice, weight, scaleToBase = true) {
+    return computeUsdValue(this, oraclePrice, quantity, priceBias, weightedPrice, weight, scaleToBase);
+  }
+  getAssetWeight(lendrRequirementType, oraclePrice, ignoreSoftLimits = false, assetWeightInitOverride) {
+    return getAssetWeight(this, lendrRequirementType, oraclePrice, {
+      ignoreSoftLimits,
+      assetWeightInitOverride
     });
-    return { stalePythFeeds, staleSwbOracles };
   }
-  return { stalePythFeeds: [], staleSwbOracles: [] };
-}
+  getLiabilityWeight(lendrRequirementType) {
+    return getLiabilityWeight(this.config, lendrRequirementType);
+  }
+  computeTvl(oraclePrice) {
+    return computeTvl(this, oraclePrice);
+  }
+  computeInterestRates() {
+    return computeInterestRates(this);
+  }
+  computeBaseInterestRate() {
+    return computeBaseInterestRate(this);
+  }
+  computeUtilizationRate() {
+    return computeUtilizationRate(this);
+  }
+  computeRemainingCapacity() {
+    return computeRemainingCapacity(this);
+  }
+  describe(oraclePrice) {
+    return `
+Bank address: ${this.address.toBase58()}
+Mint: ${this.mint.toBase58()}, decimals: ${this.mintDecimals}
 
-// src/services/group/group.service.ts
-init_constants();
-import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4 } from "@solana/spl-token";
-import { PublicKey as PublicKey23, StakeProgram as StakeProgram2, SYSVAR_RENT_PUBKEY as SYSVAR_RENT_PUBKEY2, SystemProgram as SystemProgram4, TransactionInstruction as TransactionInstruction2 } from "@solana/web3.js";
-import BN12 from "bn.js";
-init_single_spl_pool();
-async function makePoolConfigureBankIx2(program, bank, args) {
-  const ix = await instructions_default.makePoolConfigureBankIx(
-    program,
-    {
-      bank
-    },
-    { bankConfigOpt: args }
-  );
-  return {
-    instructions: [ix],
-    keys: []
-  };
-}
-async function makeAddPermissionlessStakedBankIx(program, group, voteAccountAddress, feePayer, pythOracle) {
-  const [settingsKey] = PublicKey23.findProgramAddressSync(
-    [Buffer.from("staked_settings", "utf-8"), group.toBuffer()],
-    program.programId
-  );
-  const poolAddress = findPoolAddress(voteAccountAddress);
-  const solPool = findPoolStakeAddress(poolAddress);
-  const lstMint = findPoolMintAddress(poolAddress);
-  const onRampAddress = findPoolOnRampAddress(poolAddress);
-  const keys = [
-    { pubkey: poolAddress, isSigner: false, isWritable: false },
-    { pubkey: onRampAddress, isSigner: false, isWritable: true },
-    { pubkey: solPool, isSigner: false, isWritable: false },
-    { pubkey: SYSVAR_RENT_PUBKEY2, isSigner: false, isWritable: false },
-    { pubkey: SystemProgram4.programId, isSigner: false, isWritable: false },
-    { pubkey: StakeProgram2.programId, isSigner: false, isWritable: false }
-  ];
-  const data = Buffer.from(Uint8Array.of(6));
-  const _onrampIx = new TransactionInstruction2({
-    keys,
-    programId: SINGLE_POOL_PROGRAM_ID,
-    data
-  });
-  const remainingKeys = [pythOracle, lstMint, solPool];
-  const ix = await instructions_default.makePoolAddPermissionlessStakedBankIx(
-    program,
-    {
-      stakedSettings: settingsKey,
-      feePayer,
-      bankMint: lstMint,
-      solPool,
-      stakePool: poolAddress
-    },
-    remainingKeys.map((key) => ({ pubkey: key, isSigner: false, isWritable: false })),
-    {
-      seed: new BN12(0)
-    }
-  );
-  return {
-    instructions: [ix],
-    keys: []
-  };
-}
-async function makePoolAddBankIx2(program, group, bank, feePayer, bankMint, bankConfig, tokenProgram = TOKEN_PROGRAM_ID4, overrideOpt = {}) {
-  const rawBankConfig = serializeBankConfigOpt(bankConfig);
-  const rawBankConfigCompact = {
-    ...rawBankConfig,
-    oracleMaxAge: bankConfig.oracleMaxAge,
-    auto_padding_0: [0],
-    auto_padding_1: [0]
-  };
-  const ix = await instructions_default.makePoolAddBankIx(
-    program,
-    {
-      lendrGroup: group,
-      feePayer,
-      bankMint,
-      bank,
-      tokenProgram,
-      ...overrideOpt
-      // if two oracle keys: first is feed id, second is oracle key
-    },
-    {
-      bankConfig: rawBankConfigCompact
-    }
-  );
-  return {
-    instructions: [ix],
-    //ix
-    keys: []
-  };
-}
+Total deposits: ${nativeToUi(this.getTotalAssetQuantity(), this.mintDecimals)}
+Total borrows: ${nativeToUi(this.getTotalLiabilityQuantity(), this.mintDecimals)}
 
-// src/services/group/utils/deserialize.utils.ts
-import { PublicKey as PublicKey24 } from "@solana/web3.js";
-function dtoToGroup(groupDto) {
-  return {
-    admin: new PublicKey24(groupDto.admin),
-    address: new PublicKey24(groupDto.address)
-  };
-}
+Total assets (USD value): ${this.computeAssetUsdValue(
+      oraclePrice,
+      this.totalAssetShares,
+      2 /* Equity */,
+      1 /* None */
+    )}
+Total liabilities (USD value): ${this.computeLiabilityUsdValue(
+      oraclePrice,
+      this.totalLiabilityShares,
+      2 /* Equity */,
+      1 /* None */
+    )}
 
-// src/services/group/utils/serialize.utils.ts
-function groupToDto(group) {
-  return {
-    admin: group.admin.toBase58(),
-    address: group.address.toBase58()
-  };
-}
+Asset price (USD): ${_Bank.getPrice(oraclePrice, 1 /* None */, false)}
+Asset price Weighted (USD): ${_Bank.getPrice(oraclePrice, 1 /* None */, true)}
 
-// src/services/native-stake/utils/deserialize.utils.ts
-import { PublicKey as PublicKey25 } from "@solana/web3.js";
-function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
-  return {
-    validator: new PublicKey25(validatorStakeGroupDto.validator),
-    poolKey: new PublicKey25(validatorStakeGroupDto.poolKey),
-    poolMintKey: new PublicKey25(validatorStakeGroupDto.poolMintKey),
-    totalStake: validatorStakeGroupDto.totalStake,
-    selectedAccount: {
-      pubkey: new PublicKey25(validatorStakeGroupDto.selectedAccount.pubkey),
-      amount: validatorStakeGroupDto.selectedAccount.amount
-    },
-    accounts: validatorStakeGroupDto.accounts.map((account) => ({
-      pubkey: new PublicKey25(account.pubkey),
-      amount: account.amount
-    }))
-  };
-}
+Config:
+- Asset weight init: ${this.config.assetWeightInit.toFixed(2)}
+- Asset weight maint: ${this.config.assetWeightMaint.toFixed(2)}
+- Liability weight init: ${this.config.liabilityWeightInit.toFixed(2)}
+- Liability weight maint: ${this.config.liabilityWeightMaint.toFixed(2)}
 
-// src/services/native-stake/utils/fetch.utils.ts
-init_constants();
-init_single_spl_pool();
-import { LAMPORTS_PER_SOL as LAMPORTS_PER_SOL4, PublicKey as PublicKey26, StakeProgram as StakeProgram3 } from "@solana/web3.js";
-var fetchNativeStakeAccounts = async (connection, publicKey3, opts = {
-  filterInactive: true
-}) => {
-  if (!connection || !publicKey3) {
-    throw new Error("Invalid connection or public key");
+- Deposit limit: ${this.config.depositLimit}
+- Borrow limit: ${this.config.borrowLimit}
+
+LTVs:
+- Initial: ${new BigNumber12(1).div(this.config.liabilityWeightInit).times(100).toFixed(2)}%
+- Maintenance: ${new BigNumber12(1).div(this.config.liabilityWeightMaint).times(100).toFixed(2)}%
+`;
   }
-  try {
-    const epochInfo = await connection.getEpochInfo();
-    const accounts = await connection.getParsedProgramAccounts(StakeProgram3.programId, {
-      filters: [
-        {
-          memcmp: {
-            offset: 12,
-            bytes: publicKey3.toBase58()
-          }
-        }
-      ]
-    });
-    const validatorMap = /* @__PURE__ */ new Map();
-    await Promise.all(
-      accounts.map(async (acc) => {
-        const parsedAccount = acc.account.data;
-        const stakeInfo = parsedAccount.parsed.info;
-        if (!stakeInfo.stake?.delegation || opts.filterInactive && (Number(stakeInfo.stake.delegation.activationEpoch) >= epochInfo.epoch || stakeInfo.stake.delegation.deactivationEpoch !== MAX_U64)) {
-          return;
-        }
-        const validatorAddress = stakeInfo.stake.delegation.voter;
-        const accountPubkey = acc.pubkey;
-        const amount = Number(stakeInfo.stake.delegation.stake) / LAMPORTS_PER_SOL4;
-        const existingAccounts = validatorMap.get(validatorAddress) || [];
-        validatorMap.set(validatorAddress, [...existingAccounts, { pubkey: accountPubkey, amount }]);
-      })
-    );
-    return Promise.all(
-      Array.from(validatorMap.entries()).map(async ([validatorAddress, accounts2]) => {
-        const poolKey = findPoolAddress(new PublicKey26(validatorAddress));
-        const poolMintKey = findPoolMintAddress(poolKey);
-        const totalStake = accounts2.reduce((acc, curr) => acc + curr.amount, 0);
-        const largestAccount = accounts2.reduce((acc, curr) => acc.amount > curr.amount ? acc : curr);
-        const sortedAccounts = accounts2.sort((a, b) => b.amount - a.amount);
-        if (!sortedAccounts[0].pubkey.equals(largestAccount.pubkey)) {
-          sortedAccounts.unshift(sortedAccounts.splice(sortedAccounts.indexOf(largestAccount), 1)[0]);
-        }
-        return {
-          validator: new PublicKey26(validatorAddress),
-          poolKey,
-          poolMintKey,
-          accounts: sortedAccounts,
-          totalStake,
-          selectedAccount: largestAccount
-        };
-      })
+};
+var BankConfig = class _BankConfig {
+  constructor(assetWeightInit, assetWeightMaint, liabilityWeightInit, liabilityWeightMaint, depositLimit, borrowLimit, riskTier, totalAssetValueInitLimit, assetTag, oracleSetup, oracleKeys, oracleMaxAge, interestRateConfig, operationalState, oracleMaxConfidence, fixedPrice, configFlags) {
+    this.assetWeightInit = assetWeightInit;
+    this.assetWeightMaint = assetWeightMaint;
+    this.liabilityWeightInit = liabilityWeightInit;
+    this.liabilityWeightMaint = liabilityWeightMaint;
+    this.depositLimit = depositLimit;
+    this.borrowLimit = borrowLimit;
+    this.riskTier = riskTier;
+    this.totalAssetValueInitLimit = totalAssetValueInitLimit;
+    this.assetTag = assetTag;
+    this.oracleSetup = oracleSetup;
+    this.oracleKeys = oracleKeys;
+    this.oracleMaxAge = oracleMaxAge;
+    this.interestRateConfig = interestRateConfig;
+    this.operationalState = operationalState;
+    this.oracleMaxConfidence = oracleMaxConfidence;
+    this.fixedPrice = fixedPrice;
+    this.configFlags = configFlags;
+  }
+  static fromAccountParsed(bankConfigRaw) {
+    const bankConfig = parseBankConfigRaw(bankConfigRaw);
+    return new _BankConfig(
+      bankConfig.assetWeightInit,
+      bankConfig.assetWeightMaint,
+      bankConfig.liabilityWeightInit,
+      bankConfig.liabilityWeightMaint,
+      bankConfig.depositLimit,
+      bankConfig.borrowLimit,
+      bankConfig.riskTier,
+      bankConfig.totalAssetValueInitLimit,
+      bankConfig.assetTag,
+      bankConfig.oracleSetup,
+      bankConfig.oracleKeys,
+      bankConfig.oracleMaxAge,
+      bankConfig.interestRateConfig,
+      bankConfig.operationalState,
+      bankConfig.oracleMaxConfidence,
+      bankConfig.fixedPrice,
+      bankConfig.configFlags
     );
-  } catch (e) {
-    console.error("Error getting stake accounts", e);
-    return [];
   }
 };
-var fetchStakePoolActiveStates = async (connection, validatorVoteAccounts) => {
-  const currentEpoch = await connection.getEpochInfo();
-  const activeStates = /* @__PURE__ */ new Map();
-  const poolMintAddressRecord = {};
-  const poolStakeAddressRecord = {};
-  validatorVoteAccounts.forEach((validatorVoteAccount) => {
-    const poolAddress = findPoolAddress(validatorVoteAccount);
-    const poolStakeAddress = findPoolStakeAddress(poolAddress);
-    const poolMintAddress = findPoolMintAddress(poolAddress);
-    poolMintAddressRecord[validatorVoteAccount.toBase58()] = poolMintAddress;
-    poolStakeAddressRecord[poolStakeAddress.toBase58()] = validatorVoteAccount;
-  });
-  const poolStakeAddressKeys = Object.keys(poolStakeAddressRecord);
-  const poolStakeAccounts = Object.fromEntries(
-    (await chunkedGetRawMultipleAccountInfoOrdered(connection, poolStakeAddressKeys)).map((ai, index) => [
-      poolStakeAddressRecord[poolStakeAddressKeys[index]],
-      ai?.data || null
-    ])
+
+// src/services/account/utils/emode.utils.ts
+function computeEmodeImpacts(emodePairs, activeLiabilities, activeCollateral, allBanks) {
+  const toKey = (k) => k.toBase58();
+  const basePairs = computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral);
+  const baseOn = basePairs.length > 0;
+  const liabTagMap = /* @__PURE__ */ new Map();
+  for (const p of emodePairs) {
+    liabTagMap.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
+  }
+  const existingTags = new Set(
+    activeLiabilities.map((l) => liabTagMap.get(l.toBase58())).filter((t) => !!t)
   );
-  validatorVoteAccounts.forEach((validatorVoteAccount) => {
-    const stakeAccount = fetchStakeAccount(poolStakeAccounts[validatorVoteAccount.toBase58()]);
-    const poolMintAddress = poolMintAddressRecord[validatorVoteAccount.toBase58()];
-    if (!stakeAccount) {
-      activeStates.set(poolMintAddress.toBase58(), false);
-      return;
+  function minWeight(ps) {
+    let m = ps[0].assetWeightInit;
+    for (const x of ps) if (x.assetWeightInit.lt(m)) m = x.assetWeightInit;
+    return m;
+  }
+  function diffState(before, after) {
+    const was = before.length > 0, isOn = after.length > 0;
+    if (!was && !isOn) return 5 /* InactiveEmode */;
+    if (!was && isOn) return 0 /* ActivateEmode */;
+    if (was && !isOn) return 4 /* RemoveEmode */;
+    const bMin = minWeight(before), aMin = minWeight(after);
+    if (aMin.gt(bMin)) return 2 /* IncreaseEmode */;
+    if (aMin.lt(bMin)) return 3 /* ReduceEmode */;
+    return 1 /* ExtendEmode */;
+  }
+  function simulate(bank, action) {
+    let L = [...activeLiabilities], C = [...activeCollateral];
+    switch (action) {
+      case "borrow":
+        if (!L.some((x) => x.equals(bank))) L.push(bank);
+        break;
+      case "repay":
+        L = L.filter((x) => !x.equals(bank));
+        break;
+      case "supply":
+        if (!C.some((x) => x.equals(bank))) C.push(bank);
+        break;
+      case "withdraw":
+        C = C.filter((x) => !x.equals(bank));
+        break;
     }
-    if (!stakeAccount.stake?.delegation) {
-      activeStates.set(poolMintAddress.toBase58(), false);
-      return;
+    const after = computeActiveEmodePairs(emodePairs, L, C);
+    let status = diffState(basePairs, after);
+    if (action === "borrow") {
+      const tag = liabTagMap.get(bank.toBase58());
+      if (!tag) {
+        status = baseOn ? 4 /* RemoveEmode */ : 5 /* InactiveEmode */;
+      } else if (baseOn) {
+        if (after.length === 0) {
+          status = 4 /* RemoveEmode */;
+        } else if (existingTags.has(tag)) {
+          status = 1 /* ExtendEmode */;
+        }
+      }
     }
-    const activationEpoch = stakeAccount.stake.delegation.activationEpoch;
-    const isActive = currentEpoch.epoch > Number(activationEpoch);
-    activeStates.set(validatorVoteAccount.toBase58(), isActive);
-  });
-  return activeStates;
-};
-var fetchStakeAccount = (data) => {
-  let offset = 0;
-  const discriminant = data.readUInt32LE(offset);
-  offset += 4;
-  const rentExemptReserve = data.readBigUInt64LE(offset);
-  offset += 8;
-  const staker = new PublicKey26(data.subarray(offset, offset + 32));
-  offset += 32;
-  const withdrawer = new PublicKey26(data.subarray(offset, offset + 32));
-  offset += 32;
-  const unixTimestamp = data.readBigUInt64LE(offset);
-  offset += 8;
-  const epoch = data.readBigUInt64LE(offset);
-  offset += 8;
-  const custodian = new PublicKey26(data.subarray(offset, offset + 32));
-  offset += 32;
-  const voterPubkey = new PublicKey26(data.subarray(offset, offset + 32));
-  offset += 32;
-  const stake = data.readBigUInt64LE(offset);
-  offset += 8;
-  const activationEpoch = data.readBigUInt64LE(offset);
-  offset += 8;
-  const deactivationEpoch = data.readBigUInt64LE(offset);
-  offset += 8;
-  const creditsObserved = data.readBigUInt64LE(offset);
-  return {
-    discriminant,
-    meta: {
-      rentExemptReserve,
-      authorized: {
-        staker,
-        withdrawer
-      },
-      lockup: {
-        unixTimestamp,
-        epoch,
-        custodian
+    if (action === "supply") {
+      const isOn = after.length > 0;
+      status = !baseOn && isOn ? 0 /* ActivateEmode */ : baseOn && isOn ? 1 /* ExtendEmode */ : 5 /* InactiveEmode */;
+    }
+    if (action === "withdraw") {
+      if (!baseOn) {
+        status = 5 /* InactiveEmode */;
+      } else if (after.length === 0) {
+        status = 4 /* RemoveEmode */;
+      } else {
+        const b = minWeight(basePairs), a = minWeight(after);
+        if (a.gt(b)) status = 2 /* IncreaseEmode */;
+        else if (a.lt(b)) status = 3 /* ReduceEmode */;
+        else status = 1 /* ExtendEmode */;
       }
-    },
-    stake: {
-      delegation: {
-        voterPubkey,
-        stake,
-        activationEpoch,
-        deactivationEpoch
-      },
-      creditsObserved
     }
-  };
-};
-var fetchStakePoolMev = async (connection, validatorVoteAccounts) => {
-  const poolAddressRecord = {};
-  const poolStakeAddressRecord = {};
-  const onRampAddressRecord = {};
-  const mev = /* @__PURE__ */ new Map();
-  validatorVoteAccounts.forEach((validatorVoteAccount) => {
-    const poolAddress = findPoolAddress(validatorVoteAccount);
-    const poolStakeAddress = findPoolStakeAddress(poolAddress);
-    const onRampAddress = findPoolOnRampAddress(poolAddress);
-    poolAddressRecord[validatorVoteAccount.toBase58()] = poolAddress;
-    poolStakeAddressRecord[validatorVoteAccount.toBase58()] = poolStakeAddress;
-    onRampAddressRecord[validatorVoteAccount.toBase58()] = onRampAddress;
-  });
-  const poolStakeAddresses = validatorVoteAccounts.map(
-    (validatorVoteAccount) => poolStakeAddressRecord[validatorVoteAccount.toBase58()]
+    let bestPair;
+    if (after.length > 0) {
+      bestPair = after[0];
+      for (const p of after) {
+        if (p.assetWeightInit.lt(bestPair.assetWeightInit)) {
+          bestPair = p;
+        }
+      }
+    }
+    const activeEmodePair = bestPair ? {
+      collateralBanks: Array.from(
+        new Map(after.flatMap((p) => p.collateralBanks).map((bank2) => [bank2.toBase58(), bank2])).values()
+      ),
+      collateralBankTags: Array.from(new Set(after.flatMap((p) => p.collateralBankTag))),
+      liabilityBanks: Array.from(
+        new Map(after.flatMap((p) => p.liabilityBank).map((bank2) => [bank2.toBase58(), bank2])).values()
+      ),
+      liabilityBankTags: Array.from(new Set(after.flatMap((p) => p.liabilityBankTag))),
+      assetWeightMaint: bestPair.assetWeightMaint,
+      assetWeightInit: bestPair.assetWeightInit
+    } : void 0;
+    return {
+      status,
+      resultingPairs: after,
+      activePair: activeEmodePair
+    };
+  }
+  const result = {};
+  for (const bank of allBanks) {
+    const key = toKey(bank);
+    const impact = {};
+    if (!activeCollateral.some((x) => x.equals(bank))) {
+      impact.borrowImpact = simulate(bank, "borrow");
+    }
+    const collSet = new Set(emodePairs.flatMap((p) => p.collateralBanks.map((c) => c.toBase58())));
+    if (collSet.has(key) && !activeCollateral.some((x) => x.equals(bank)) && !activeLiabilities.some((x) => x.equals(bank))) {
+      impact.supplyImpact = simulate(bank, "supply");
+    }
+    if (activeLiabilities.some((x) => x.equals(bank))) {
+      impact.repayAllImpact = simulate(bank, "repay");
+    }
+    if (activeCollateral.some((x) => x.equals(bank))) {
+      impact.withdrawAllImpact = simulate(bank, "withdraw");
+    }
+    result[key] = impact;
+  }
+  return result;
+}
+function computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral) {
+  const configured = emodePairs.filter((p) => p.collateralBankTag !== EmodeTag.UNSET);
+  const liabTagByBank = /* @__PURE__ */ new Map();
+  for (const p of configured) {
+    liabTagByBank.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
+  }
+  const requiredTags = /* @__PURE__ */ new Set();
+  for (const liab of activeLiabilities) {
+    const tag = liabTagByBank.get(liab.toBase58());
+    if (!tag) {
+      return [];
+    }
+    requiredTags.add(tag);
+  }
+  const possible = configured.filter(
+    (p) => activeLiabilities.some((l) => l.equals(p.liabilityBank)) && p.collateralBanks.some((c) => activeCollateral.some((a) => a.equals(c)))
   );
-  const onRampAddresses = validatorVoteAccounts.map(
-    (validatorVoteAccount) => onRampAddressRecord[validatorVoteAccount.toBase58()]
+  if (possible.length === 0) return [];
+  const byCollTag = {};
+  for (const p of possible) {
+    const ct = p.collateralBankTag.toString();
+    if (!byCollTag[ct]) {
+      byCollTag[ct] = [];
+    }
+    byCollTag[ct].push(p);
+  }
+  const validGroups = [];
+  for (const group of Object.values(byCollTag)) {
+    const supports = new Set(group.map((p) => p.liabilityBankTag.toString()));
+    let coversAll = true;
+    for (const rt of requiredTags) {
+      if (!supports.has(rt)) {
+        coversAll = false;
+        break;
+      }
+    }
+    if (coversAll) {
+      validGroups.push(group);
+    }
+  }
+  if (validGroups.length === 0) return [];
+  return validGroups.flat();
+}
+function getEmodePairs(banks) {
+  return banks.filter(
+    (b) => b.emode.emodeTag !== EmodeTag.UNSET || b.emode.emodeEntries.some((e) => e.collateralBankEmodeTag !== 0)
+  ).flatMap(
+    (bank) => bank.emode.emodeEntries.map((entry) => ({
+      collateralBanks: banks.filter((b) => b.emode.emodeTag === entry.collateralBankEmodeTag && !b.address.equals(bank.address)).map((b) => b.address),
+      collateralBankTag: entry.collateralBankEmodeTag,
+      liabilityBank: bank.address,
+      liabilityBankTag: bank.emode.emodeTag,
+      assetWeightMaint: entry.assetWeightMaint,
+      assetWeightInit: entry.assetWeightInit
+    })).filter((pair) => pair.collateralBanks.length > 0)
   );
-  const allAddresses = [...poolStakeAddresses, ...onRampAddresses].map((address) => address.toBase58());
-  return chunkedGetRawMultipleAccountInfoOrdered(connection, allAddresses).then((accountInfos) => {
-    const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
-    const onRampInfos = accountInfos.slice(poolStakeAddresses.length);
-    const rent = 2282280;
-    validatorVoteAccounts.forEach((validatorVoteAccount, index) => {
-      const poolStakeInfo = poolStakeInfos[index];
-      const onRampInfo = onRampInfos[index];
-      if (poolStakeInfo && onRampInfo) {
-        const stakeDecoded = fetchStakeAccount(poolStakeInfo.data);
-        const onrampDecoded = fetchStakeAccount(onRampInfo.data);
-        const poolLamps = poolStakeInfo.lamports - rent - Number(stakeDecoded.stake.delegation.stake.toString());
-        const onrampStake = Number(onrampDecoded.stake.delegation.stake.toString());
-        mev.set(validatorVoteAccount.toBase58(), {
-          pool: poolLamps >= 1e3 ? poolLamps : 0,
-          onramp: onrampStake
+}
+function adjustBanksWithEmode(banks, emodePairs) {
+  const originalAssetWeightsMap = /* @__PURE__ */ new Map();
+  if (emodePairs.length === 0) {
+    return { adjustedBanks: banks, originalAssetWeightsMap };
+  }
+  const lowestWeights = /* @__PURE__ */ new Map();
+  for (const pair of emodePairs) {
+    for (const collateralBankPk of pair.collateralBanks) {
+      const bankPkStr = collateralBankPk.toString();
+      const current = lowestWeights.get(bankPkStr);
+      if (!current) {
+        lowestWeights.set(bankPkStr, {
+          assetWeightMaint: pair.assetWeightMaint,
+          assetWeightInit: pair.assetWeightInit
         });
+        continue;
       }
+      lowestWeights.set(bankPkStr, {
+        assetWeightMaint: BigNumber13.min(current.assetWeightMaint, pair.assetWeightMaint),
+        assetWeightInit: BigNumber13.min(current.assetWeightInit, pair.assetWeightInit)
+      });
+    }
+  }
+  const adjustedBanks = banks.map((bank) => {
+    const bankPkStr = bank.address.toString();
+    const lowestWeight = lowestWeights.get(bankPkStr);
+    if (!lowestWeight) return bank;
+    originalAssetWeightsMap.set(bankPkStr, {
+      assetWeightMaint: bank.config.assetWeightMaint,
+      assetWeightInit: bank.config.assetWeightInit
     });
-    return mev;
+    return Bank.withEmodeWeights(bank, {
+      assetWeightMaint: BigNumber13.max(lowestWeight.assetWeightMaint, bank.config.assetWeightMaint),
+      assetWeightInit: BigNumber13.max(lowestWeight.assetWeightInit, bank.config.assetWeightInit)
+    });
+  });
+  return { adjustedBanks, originalAssetWeightsMap };
+}
+function makeEmodeAssetWeights(bank, pair) {
+  if (!pair) return void 0;
+  return {
+    assetWeightInit: BigNumber13.max(pair.assetWeightInit, bank.config.assetWeightInit),
+    assetWeightMaint: BigNumber13.max(pair.assetWeightMaint, bank.config.assetWeightMaint),
+    collateralTags: "collateralBankTags" in pair ? pair.collateralBankTags : [pair.collateralBankTag]
+  };
+}
+
+// src/services/account/utils/fetch.utils.ts
+var fetchLendrAccountAddresses = async (program, authority, group) => {
+  const lendrAccounts = (await program.account.lendrAccount.all([
+    {
+      memcmp: {
+        bytes: group.toBase58(),
+        offset: 8
+        // lendrGroup is the first field in the account, so only offset is the discriminant
+      }
+    },
+    {
+      memcmp: {
+        bytes: authority.toBase58(),
+        offset: 8 + 32
+        // authority is the second field in the account after the authority, so offset by the discriminant and a pubkey
+      }
+    }
+  ])).map((a) => a.publicKey);
+  return lendrAccounts;
+};
+var fetchLendrAccountData = async (program, lendrAccountPk, bankMap, oraclePrices, bankMetadataMap) => {
+  const lendrAccountRaw = await program.account.lendrAccount.fetch(lendrAccountPk, "confirmed");
+  const lendrAccount = LendrAccount.fromAccountParsed(lendrAccountPk, lendrAccountRaw);
+  const lendrAccountWithCache = await simulateAccountHealthCacheWithFallback({
+    program,
+    lendrAccount,
+    bankMap,
+    oraclePrices,
+    bankMetadataMap,
+    balances: lendrAccount.balances
   });
+  return lendrAccountWithCache;
 };
 
-// src/services/native-stake/utils/serialize.utils.ts
-function validatorStakeGroupToDto(validatorStakeGroup) {
+// src/services/account/utils/serialize.utils.ts
+import BN10 from "bn.js";
+function accountFlagToBN(flag) {
+  return new BN10(flag);
+}
+function lendrAccountToDto(lendrAccount) {
   return {
-    validator: validatorStakeGroup.validator.toBase58(),
-    poolKey: validatorStakeGroup.poolKey.toBase58(),
-    poolMintKey: validatorStakeGroup.poolMintKey.toBase58(),
-    totalStake: validatorStakeGroup.totalStake,
-    selectedAccount: {
-      pubkey: validatorStakeGroup.selectedAccount.pubkey.toBase58(),
-      amount: validatorStakeGroup.selectedAccount.amount
-    },
-    accounts: validatorStakeGroup.accounts.map((account) => ({
-      pubkey: account.pubkey.toBase58(),
-      amount: account.amount
-    }))
+    address: lendrAccount.address.toBase58(),
+    group: lendrAccount.group.toBase58(),
+    authority: lendrAccount.authority.toBase58(),
+    balances: lendrAccount.balances.map(balanceToDto),
+    accountFlags: lendrAccount.accountFlags,
+    emissionsDestinationAccount: lendrAccount.emissionsDestinationAccount.toBase58(),
+    healthCache: healthCacheToDto(lendrAccount.healthCache)
+  };
+}
+function balanceToDto(balance) {
+  return {
+    active: balance.active,
+    bankPk: balance.bankPk.toBase58(),
+    assetShares: balance.assetShares.toString(),
+    liabilityShares: balance.liabilityShares.toString(),
+    emissionsOutstanding: balance.emissionsOutstanding.toString(),
+    lastUpdate: balance.lastUpdate
+  };
+}
+function healthCacheToDto(healthCache) {
+  return {
+    assetValue: healthCache.assetValue.toString(),
+    liabilityValue: healthCache.liabilityValue.toString(),
+    assetValueMaint: healthCache.assetValueMaint.toString(),
+    liabilityValueMaint: healthCache.liabilityValueMaint.toString(),
+    assetValueEquity: healthCache.assetValueEquity.toString(),
+    liabilityValueEquity: healthCache.liabilityValueEquity.toString(),
+    timestamp: healthCache.timestamp.toString(),
+    flags: healthCache.flags,
+    prices: healthCache.prices,
+    simulationFailed: healthCache.simulationFailed
   };
 }
 
-// src/models/bank.ts
-import BigNumber13 from "bignumber.js";
-var SECONDS_PER_DAY2 = 24 * 60 * 60;
-var _SECONDS_PER_YEAR = SECONDS_PER_DAY2 * 365.25;
-var Bank = class _Bank {
-  constructor(address, mint, mintDecimals, group, mintRate, mintPrice, assetShareValue, liabilityShareValue, liquidityVault, liquidityVaultBump, liquidityVaultAuthorityBump, insuranceVault, insuranceVaultBump, insuranceVaultAuthorityBump, collectedInsuranceFeesOutstanding, feeVault, feeVaultBump, feeVaultAuthorityBump, collectedGroupFeesOutstanding, lastUpdate, config, totalAssetShares, totalLiabilityShares, flags, emissionsActiveBorrowing, emissionsActiveLending, emissionsRate, emissionsMint, emissionsRemaining, oracleKey, emode, feesDestinationAccount, lendingPositionCount, borrowingPositionCount, pythShardId, tokenSymbol, extendedMetadata, owner) {
-    this.address = address;
-    this.mint = mint;
-    this.mintDecimals = mintDecimals;
-    this.group = group;
-    this.mintRate = mintRate;
-    this.mintPrice = mintPrice;
-    this.assetShareValue = assetShareValue;
-    this.liabilityShareValue = liabilityShareValue;
-    this.liquidityVault = liquidityVault;
-    this.liquidityVaultBump = liquidityVaultBump;
-    this.liquidityVaultAuthorityBump = liquidityVaultAuthorityBump;
-    this.insuranceVault = insuranceVault;
-    this.insuranceVaultBump = insuranceVaultBump;
-    this.insuranceVaultAuthorityBump = insuranceVaultAuthorityBump;
-    this.collectedInsuranceFeesOutstanding = collectedInsuranceFeesOutstanding;
-    this.feeVault = feeVault;
-    this.feeVaultBump = feeVaultBump;
-    this.feeVaultAuthorityBump = feeVaultAuthorityBump;
-    this.collectedGroupFeesOutstanding = collectedGroupFeesOutstanding;
-    this.lastUpdate = lastUpdate;
-    this.config = config;
-    this.totalAssetShares = totalAssetShares;
-    this.totalLiabilityShares = totalLiabilityShares;
-    this.flags = flags;
-    this.emissionsActiveBorrowing = emissionsActiveBorrowing;
-    this.emissionsActiveLending = emissionsActiveLending;
-    this.emissionsRate = emissionsRate;
-    this.emissionsMint = emissionsMint;
-    this.emissionsRemaining = emissionsRemaining;
-    this.oracleKey = oracleKey;
-    this.emode = emode;
-    this.feesDestinationAccount = feesDestinationAccount;
-    this.lendingPositionCount = lendingPositionCount;
-    this.borrowingPositionCount = borrowingPositionCount;
-    this.pythShardId = pythShardId;
-    this.tokenSymbol = tokenSymbol;
-    this.extendedMetadata = extendedMetadata;
-    this.owner = owner;
-  }
-  static decodeBankRaw(encoded, idl) {
-    return decodeBankRaw(encoded, idl);
-  }
-  static fromBuffer(bankPk, rawData, idl, feedIdMap) {
-    const accountParsed = _Bank.decodeBankRaw(rawData, idl);
-    return _Bank.fromAccountParsed(bankPk, accountParsed, feedIdMap);
+// src/services/account/account.service.ts
+var HealthCacheSimulationError = class _HealthCacheSimulationError extends Error {
+  lndrErr;
+  internalErr;
+  constructor(message, lndrErr, internalErr) {
+    super(message);
+    this.name = "HealthCacheSimulationError";
+    this.lndrErr = lndrErr;
+    this.internalErr = internalErr;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _HealthCacheSimulationError);
+    }
   }
-  static fromBankType(bankType) {
-    const config = new BankConfig(
-      bankType.config.assetWeightInit,
-      bankType.config.assetWeightMaint,
-      bankType.config.liabilityWeightInit,
-      bankType.config.liabilityWeightMaint,
-      bankType.config.depositLimit,
-      bankType.config.borrowLimit,
-      bankType.config.riskTier,
-      bankType.config.totalAssetValueInitLimit,
-      bankType.config.assetTag,
-      bankType.config.oracleSetup,
-      bankType.config.oracleKeys,
-      bankType.config.oracleMaxAge,
-      bankType.config.interestRateConfig,
-      bankType.config.operationalState,
-      bankType.config.oracleMaxConfidence,
-      bankType.config.fixedPrice,
-      bankType.config.configFlags
+};
+async function simulateAccountHealthCacheWithFallback(props) {
+  let lendrAccount = props.lendrAccount;
+  const activeBalances = props.balances.filter((b) => b.active);
+  const { assets: assetValueEquity, liabilities: liabilityValueEquity } = computeHealthComponentsWithoutBiasLegacy(
+    activeBalances,
+    props.bankMap,
+    props.oraclePrices,
+    2 /* Equity */
+  );
+  try {
+    const simulatedAccount = await simulateAccountHealthCache({
+      program: props.program,
+      bankMap: props.bankMap,
+      oraclePrices: props.oraclePrices,
+      lendrAccountPk: props.lendrAccount.address,
+      balances: props.balances,
+      bankMetadataMap: props.bankMetadataMap
+    });
+    simulatedAccount.healthCache.assetValueEquity = bigNumberToWrappedI80F48(assetValueEquity);
+    simulatedAccount.healthCache.liabilityValueEquity = bigNumberToWrappedI80F48(liabilityValueEquity);
+    lendrAccount = LendrAccount.fromAccountParsed(props.lendrAccount.address, simulatedAccount);
+  } catch (e) {
+    console.log("e", e);
+    const { assets: assetValueMaint, liabilities: liabilityValueMaint } = computeHealthComponentsLegacy(
+      activeBalances,
+      props.bankMap,
+      props.oraclePrices,
+      1 /* Maintenance */
     );
-    return new _Bank(
-      bankType.address,
-      bankType.mint,
-      bankType.mintDecimals,
-      bankType.group,
-      bankType.mintRate,
-      bankType.mintPrice,
-      bankType.assetShareValue,
-      bankType.liabilityShareValue,
-      bankType.liquidityVault,
-      bankType.liquidityVaultBump,
-      bankType.liquidityVaultAuthorityBump,
-      bankType.insuranceVault,
-      bankType.insuranceVaultBump,
-      bankType.insuranceVaultAuthorityBump,
-      bankType.collectedInsuranceFeesOutstanding,
-      bankType.feeVault,
-      bankType.feeVaultBump,
-      bankType.feeVaultAuthorityBump,
-      bankType.collectedGroupFeesOutstanding,
-      bankType.lastUpdate,
-      config,
-      bankType.totalAssetShares,
-      bankType.totalLiabilityShares,
-      bankType.flags,
-      bankType.emissionsActiveBorrowing,
-      bankType.emissionsActiveLending,
-      bankType.emissionsRate,
-      bankType.emissionsMint,
-      bankType.emissionsRemaining,
-      bankType.oracleKey,
-      bankType.emode,
-      bankType.feesDestinationAccount,
-      bankType.lendingPositionCount,
-      bankType.borrowingPositionCount,
-      bankType.pythShardId,
-      bankType.tokenSymbol
+    const { assets: assetValueInitial, liabilities: liabilityValueInitial } = computeHealthComponentsLegacy(
+      activeBalances,
+      props.bankMap,
+      props.oraclePrices,
+      0 /* Initial */
     );
-  }
-  static fromAccountParsed(address, accountParsed, feedIdMap, extendedMetadata, owner) {
-    const props = parseBankRaw(address, accountParsed, feedIdMap);
-    return new _Bank(
-      props.address,
-      props.mint,
-      props.mintDecimals,
-      props.group,
-      props.mintRate,
-      props.mintPrice,
-      props.assetShareValue,
-      props.liabilityShareValue,
-      props.liquidityVault,
-      props.liquidityVaultBump,
-      props.liquidityVaultAuthorityBump,
-      props.insuranceVault,
-      props.insuranceVaultBump,
-      props.insuranceVaultAuthorityBump,
-      props.collectedInsuranceFeesOutstanding,
-      props.feeVault,
-      props.feeVaultBump,
-      props.feeVaultAuthorityBump,
-      props.collectedGroupFeesOutstanding,
-      props.lastUpdate,
-      props.config,
-      props.totalAssetShares,
-      props.totalLiabilityShares,
-      props.flags,
-      props.emissionsActiveBorrowing,
-      props.emissionsActiveLending,
-      props.emissionsRate,
-      props.emissionsMint,
-      props.emissionsRemaining,
-      props.oracleKey,
-      props.emode,
-      props.feesDestinationAccount,
-      props.lendingPositionCount,
-      props.borrowingPositionCount,
-      props.pythShardId,
-      extendedMetadata?.symbol,
-      extendedMetadata,
-      owner
+    lendrAccount.setHealthCache(
+      new HealthCache(
+        assetValueInitial,
+        liabilityValueInitial,
+        assetValueMaint,
+        liabilityValueMaint,
+        assetValueEquity,
+        liabilityValueEquity,
+        new BigNumber14(0),
+        [],
+        [],
+        true
+      )
     );
+    if (e instanceof HealthCacheSimulationError) {
+      return { lendrAccount, error: e };
+    }
   }
-  static withEmodeWeights(bank, emodeWeights) {
-    const newBank = Object.create(_Bank.prototype);
-    Object.assign(newBank, bank);
-    newBank.config = Object.assign({}, bank.config);
-    newBank.config.assetWeightInit = BigNumber13.max(bank.config.assetWeightInit, emodeWeights.assetWeightInit);
-    newBank.config.assetWeightMaint = BigNumber13.max(bank.config.assetWeightMaint, emodeWeights.assetWeightMaint);
-    return newBank;
-  }
-  static getPrice(oraclePrice, priceBias = 1 /* None */, weightedPrice = false) {
-    return getPrice(oraclePrice, priceBias, weightedPrice);
-  }
-  static computeQuantityFromUsdValue(oraclePrice, usdValue, priceBias, weightedPrice) {
-    const price = getPrice(oraclePrice, priceBias, weightedPrice);
-    return usdValue.div(price);
-  }
-  getTotalAssetQuantity() {
-    return getTotalAssetQuantity(this);
-  }
-  getTotalLiabilityQuantity() {
-    return getTotalLiabilityQuantity(this);
-  }
-  getAssetQuantity(assetShares) {
-    return getAssetQuantity(this, assetShares);
-  }
-  getLiabilityQuantity(liabilityShares) {
-    return getLiabilityQuantity(this, liabilityShares);
-  }
-  getAssetShares(assetQuantity) {
-    return getAssetShares(this, assetQuantity);
-  }
-  getLiabilityShares(liabilityQuantity) {
-    return getLiabilityShares(this, liabilityQuantity);
-  }
-  computeAssetUsdValue(oraclePrice, assetShares, lendrRequirementType, priceBias) {
-    return computeAssetUsdValue(this, oraclePrice, assetShares, lendrRequirementType, priceBias);
+  return { lendrAccount };
+}
+async function simulateAccountHealthCache(props) {
+  const { program, bankMap, oraclePrices, lendrAccountPk, balances, bankMetadataMap } = props;
+  const activeBalances = balances.filter((b) => b.active);
+  const { staleSwbOracles } = getActiveStaleBanks(activeBalances, bankMap, [], oraclePrices, 30);
+  const computeIx = ComputeBudgetProgram4.setComputeUnitLimit({ units: 14e5 });
+  const blockhash = (await program.provider.connection.getLatestBlockhash("confirmed")).blockhash;
+  const fundAccountIx = SystemProgram3.transfer({
+    fromPubkey: new PublicKey22("DD3AeAssFvjqTvRTrRAtpfjkBF8FpVKnFuwnMLN9haXD"),
+    // lendr SOL VAULT
+    toPubkey: program.provider.publicKey,
+    lamports: 1e8
+    // 0.1 SOL
+  });
+  const crankPythIxs = {
+    postInstructions: [],
+    closeInstructions: [],
+    keys: [],
+    lut: null
+  };
+  const crankSwbIxs = staleSwbOracles.length > 0 ? await createUpdateFeedIx({
+    swbPullOracles: staleSwbOracles.map((oracle) => oracle.oracleKey),
+    provider: program.provider
+  }) : { instructions: [], luts: [] };
+  const healthPulseIxs = await makePulseHealthIx2(
+    program,
+    lendrAccountPk,
+    bankMap,
+    balances,
+    activeBalances.map((b) => b.bankPk),
+    [],
+    bankMetadataMap
+  );
+  const pythLut = crankPythIxs.lut ? [crankPythIxs.lut] : [];
+  const txs = [];
+  if (crankPythIxs.postInstructions.length > 0) {
+    txs.push(
+      ...splitInstructionsToFitTransactions(
+        [computeIx],
+        [
+          fundAccountIx,
+          ...crankPythIxs.postInstructions.map((ix) => ix.instruction),
+          ...crankPythIxs.closeInstructions.map((ix) => ix.instruction)
+        ],
+        {
+          blockhash,
+          payerKey: program.provider.publicKey,
+          luts: [...crankSwbIxs.luts, ...pythLut]
+        }
+      )
+    );
   }
-  computeLiabilityUsdValue(oraclePrice, liabilityShares, lendrRequirementType, priceBias) {
-    return computeLiabilityUsdValue(this, oraclePrice, liabilityShares, lendrRequirementType, priceBias);
+  const messageV0 = new TransactionMessage4({
+    payerKey: program.provider.publicKey,
+    recentBlockhash: blockhash,
+    instructions: [...crankSwbIxs.instructions]
+  }).compileToV0Message([...crankSwbIxs.luts]);
+  const swbTx = new VersionedTransaction4(messageV0);
+  txs.push(swbTx);
+  const healthTx = new TransactionMessage4({
+    payerKey: program.provider.publicKey,
+    recentBlockhash: blockhash,
+    instructions: [...healthPulseIxs.instructions]
+  }).compileToV0Message([]);
+  const healthTxV0 = new VersionedTransaction4(healthTx);
+  txs.push(healthTxV0);
+  if (txs.length > 5) {
+    console.error("Too many transactions", txs.length);
+    throw new Error("Too many transactions");
   }
-  computeUsdValue(oraclePrice, quantity, priceBias, weightedPrice, weight, scaleToBase = true) {
-    return computeUsdValue(this, oraclePrice, quantity, priceBias, weightedPrice, weight, scaleToBase);
+  const simulationResult = await simulateBundle(program.provider.connection.rpcEndpoint, txs, [lendrAccountPk]);
+  const postExecutionAccount = simulationResult.find((result) => result.postExecutionAccounts.length > 0);
+  if (!postExecutionAccount) {
+    throw new Error("Account not found");
   }
-  getAssetWeight(lendrRequirementType, oraclePrice, ignoreSoftLimits = false, assetWeightInitOverride) {
-    return getAssetWeight(this, lendrRequirementType, oraclePrice, {
-      ignoreSoftLimits,
-      assetWeightInitOverride
+  const lendrAccountPost = LendrAccount.decodeAccountRaw(
+    Buffer.from(postExecutionAccount.postExecutionAccounts[0].data[0], "base64"),
+    program.idl
+  );
+  if (lendrAccountPost.healthCache.lndrErr || lendrAccountPost.healthCache.internalErr) {
+    console.log(
+      "cranked swb oracles",
+      staleSwbOracles.map((oracle) => oracle.oracleKey)
+    );
+    console.log("LendrAccountPost healthCache internalErr", lendrAccountPost.healthCache.internalErr);
+    console.log("LendrAccountPost healthCache lndrErr", lendrAccountPost.healthCache.lndrErr);
+    if (lendrAccountPost.healthCache.lndrErr === 6009) {
+      const assetValue = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValue).isZero();
+      const liabilityValue = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.liabilityValue).isZero();
+      const assetValueEquity = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValueEquity).isZero();
+      const liabilityValueEquity = !wrappedI80F48toBigNumber(
+        lendrAccountPost.healthCache.liabilityValueEquity
+      ).isZero();
+      const assetValueMaint = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.assetValueMaint).isZero();
+      const liabilityValueMaint = !wrappedI80F48toBigNumber(lendrAccountPost.healthCache.liabilityValueMaint).isZero();
+      if (assetValue && liabilityValue && assetValueEquity && liabilityValueEquity && assetValueMaint && liabilityValueMaint) {
+        return lendrAccountPost;
+      }
+    }
+    console.error("Account health cache simulation failed", {
+      lndrErr: lendrAccountPost.healthCache.lndrErr,
+      internalErr: lendrAccountPost.healthCache.internalErr
     });
+    throw new HealthCacheSimulationError(
+      "Account health cache simulation failed",
+      lendrAccountPost.healthCache.lndrErr,
+      lendrAccountPost.healthCache.internalErr
+    );
   }
-  getLiabilityWeight(lendrRequirementType) {
-    return getLiabilityWeight(this.config, lendrRequirementType);
-  }
-  computeTvl(oraclePrice) {
-    return computeTvl(this, oraclePrice);
-  }
-  computeInterestRates() {
-    return computeInterestRates(this);
-  }
-  computeBaseInterestRate() {
-    return computeBaseInterestRate(this);
-  }
-  computeUtilizationRate() {
-    return computeUtilizationRate(this);
-  }
-  computeRemainingCapacity() {
-    return computeRemainingCapacity(this);
+  return lendrAccountPost;
+}
+async function makePulseHealthIx2(program, lendrAccountPk, banks, balances, mandatoryBanks, excludedBanks, bankMetadataMap) {
+  const healthAccounts = computeHealthCheckAccounts(balances, banks, mandatoryBanks, excludedBanks);
+  const accountMetas = computeHealthAccountMetas(healthAccounts, bankMetadataMap);
+  const ix = await instructions_default.makePulseHealthIx(
+    program,
+    {
+      lendrAccount: lendrAccountPk
+    },
+    accountMetas.map((account) => ({ pubkey: account, isSigner: false, isWritable: false }))
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function createUpdateFeedIx(_props) {
+  throw new Error("in terms of switchboard, we have no switchboard");
+}
+async function createLendrAccountTx(props) {
+  const authority = props.lendrAccount?.authority ?? props.lendrClient.provider.publicKey;
+  const lendrAccountKeypair = Keypair2.generate();
+  const dummyWrappedI80F48 = bigNumberToWrappedI80F48(new BigNumber14(0));
+  const dummyBalances = Array(15).fill({
+    active: false,
+    bankPk: new PublicKey22("11111111111111111111111111111111"),
+    assetShares: dummyWrappedI80F48,
+    liabilityShares: dummyWrappedI80F48,
+    emissionsOutstanding: dummyWrappedI80F48,
+    lastUpdate: new BN11(0)
+  });
+  const rawAccount = {
+    group: props.lendrClient.group.address,
+    authority,
+    lendingAccount: { balances: dummyBalances },
+    healthCache: {
+      assetValue: {
+        value: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      liabilityValue: {
+        value: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      timestamp: new BN11(0),
+      flags: 0,
+      prices: [],
+      assetValueMaint: bigNumberToWrappedI80F48(new BigNumber14(0)),
+      liabilityValueMaint: bigNumberToWrappedI80F48(new BigNumber14(0)),
+      assetValueEquity: bigNumberToWrappedI80F48(new BigNumber14(0)),
+      liabilityValueEquity: bigNumberToWrappedI80F48(new BigNumber14(0)),
+      errIndex: 0,
+      internalErr: 0,
+      internalBankruptcyErr: 0,
+      internalLiqErr: 0,
+      lndrErr: 0
+    },
+    emissionsDestinationAccount: new PublicKey22("11111111111111111111111111111111"),
+    accountFlags: new BN11([0, 0, 0])
+  };
+  const account = LendrAccount.fromAccountParsed(lendrAccountKeypair.publicKey, rawAccount);
+  const wrappedAccount = new LendrAccountWrapper(lendrAccountKeypair.publicKey, props.lendrClient, account);
+  return {
+    account: wrappedAccount,
+    tx: await props.lendrClient.createLendrAccountTx({ accountKeypair: lendrAccountKeypair })
+  };
+}
+function getActiveStaleBanks(balances, banks, additionalBanks, oraclePrices, maxAgeOffset = 0) {
+  const activeBanks = balances.filter((balance) => balance.active).map((balance) => banks.get(balance.bankPk.toBase58())).filter((bank) => !!bank);
+  const allBanks = [...activeBanks, ...additionalBanks];
+  const staleBanks = allBanks.filter((bank) => {
+    if (bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "SwitchboardV2" /* SwitchboardV2 */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */) {
+      return true;
+    }
+    const oraclePrice = oraclePrices.get(bank.address.toBase58());
+    const maxAge = bank.config.oracleMaxAge;
+    const currentTime = Math.round(Date.now() / 1e3);
+    const oracleTime = Math.round(oraclePrice?.timestamp ? oraclePrice.timestamp.toNumber() : Date.now());
+    const adjustedMaxAge = Math.max(maxAge - maxAgeOffset, 0);
+    const isStale = currentTime - oracleTime > adjustedMaxAge;
+    return isStale;
+  });
+  if (staleBanks.length > 0) {
+    const stalePythFeeds = [];
+    const staleSwbOracles = [];
+    const seenSwbOracles = /* @__PURE__ */ new Set();
+    const seenPythFeeds = /* @__PURE__ */ new Set();
+    staleBanks.forEach((bank) => {
+      if (bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */) {
+        const key = bank.oracleKey.toBase58();
+        if (!seenSwbOracles.has(key)) {
+          seenSwbOracles.add(key);
+          staleSwbOracles.push({ oracleKey: bank.oracleKey });
+        }
+      } else if (bank.config.oracleSetup === "PythPushOracle" /* PythPushOracle */ || bank.config.oracleSetup === "StakedWithPythPush" /* StakedWithPythPush */ || bank.config.oracleSetup === "KaminoPythPush" /* KaminoPythPush */) {
+        const oraclePrice = oraclePrices.get(bank.address.toBase58());
+        const shardId = oraclePrice?.pythShardId ?? 0;
+        const feedId = bank.config.oracleKeys[0];
+        const feedKey = feedIdToString(feedId);
+        if (!seenPythFeeds.has(feedKey)) {
+          seenPythFeeds.add(feedKey);
+          stalePythFeeds.push({ feedId: feedKey, shardId });
+        }
+      }
+    });
+    return { stalePythFeeds, staleSwbOracles };
   }
-  describe(oraclePrice) {
-    return `
-Bank address: ${this.address.toBase58()}
-Mint: ${this.mint.toBase58()}, decimals: ${this.mintDecimals}
-
-Total deposits: ${nativeToUi(this.getTotalAssetQuantity(), this.mintDecimals)}
-Total borrows: ${nativeToUi(this.getTotalLiabilityQuantity(), this.mintDecimals)}
+  return { stalePythFeeds: [], staleSwbOracles: [] };
+}
 
-Total assets (USD value): ${this.computeAssetUsdValue(
-      oraclePrice,
-      this.totalAssetShares,
-      2 /* Equity */,
-      1 /* None */
-    )}
-Total liabilities (USD value): ${this.computeLiabilityUsdValue(
-      oraclePrice,
-      this.totalLiabilityShares,
-      2 /* Equity */,
-      1 /* None */
-    )}
+// src/services/group/group.service.ts
+init_constants();
+import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4 } from "@solana/spl-token";
+import { PublicKey as PublicKey23, StakeProgram as StakeProgram2, SYSVAR_RENT_PUBKEY as SYSVAR_RENT_PUBKEY2, SystemProgram as SystemProgram4, TransactionInstruction as TransactionInstruction2 } from "@solana/web3.js";
+import BN12 from "bn.js";
+init_single_spl_pool();
+async function makePoolConfigureBankIx2(program, bank, args) {
+  const ix = await instructions_default.makePoolConfigureBankIx(
+    program,
+    {
+      bank
+    },
+    { bankConfigOpt: args }
+  );
+  return {
+    instructions: [ix],
+    keys: []
+  };
+}
+async function makeAddPermissionlessStakedBankIx(program, group, voteAccountAddress, feePayer, pythOracle) {
+  const [settingsKey] = PublicKey23.findProgramAddressSync(
+    [Buffer.from("staked_settings", "utf-8"), group.toBuffer()],
+    program.programId
+  );
+  const poolAddress = findPoolAddress(voteAccountAddress);
+  const solPool = findPoolStakeAddress(poolAddress);
+  const lstMint = findPoolMintAddress(poolAddress);
+  const onRampAddress = findPoolOnRampAddress(poolAddress);
+  const keys = [
+    { pubkey: poolAddress, isSigner: false, isWritable: false },
+    { pubkey: onRampAddress, isSigner: false, isWritable: true },
+    { pubkey: solPool, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_RENT_PUBKEY2, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram4.programId, isSigner: false, isWritable: false },
+    { pubkey: StakeProgram2.programId, isSigner: false, isWritable: false }
+  ];
+  const data = Buffer.from(Uint8Array.of(6));
+  const _onrampIx = new TransactionInstruction2({
+    keys,
+    programId: SINGLE_POOL_PROGRAM_ID,
+    data
+  });
+  const remainingKeys = [pythOracle, lstMint, solPool];
+  const ix = await instructions_default.makePoolAddPermissionlessStakedBankIx(
+    program,
+    {
+      stakedSettings: settingsKey,
+      feePayer,
+      bankMint: lstMint,
+      solPool,
+      stakePool: poolAddress
+    },
+    remainingKeys.map((key) => ({ pubkey: key, isSigner: false, isWritable: false })),
+    {
+      seed: new BN12(0)
+    }
+  );
+  return {
+    instructions: [ix],
+    keys: []
+  };
+}
+async function makePoolAddBankIx2(program, group, bank, feePayer, bankMint, bankConfig, tokenProgram = TOKEN_PROGRAM_ID4, overrideOpt = {}) {
+  const rawBankConfig = serializeBankConfigOpt(bankConfig);
+  const rawBankConfigCompact = {
+    ...rawBankConfig,
+    oracleMaxAge: bankConfig.oracleMaxAge,
+    auto_padding_0: [0],
+    auto_padding_1: [0]
+  };
+  const ix = await instructions_default.makePoolAddBankIx(
+    program,
+    {
+      lendrGroup: group,
+      feePayer,
+      bankMint,
+      bank,
+      tokenProgram,
+      ...overrideOpt
+      // if two oracle keys: first is feed id, second is oracle key
+    },
+    {
+      bankConfig: rawBankConfigCompact
+    }
+  );
+  return {
+    instructions: [ix],
+    //ix
+    keys: []
+  };
+}
 
-Asset price (USD): ${_Bank.getPrice(oraclePrice, 1 /* None */, false)}
-Asset price Weighted (USD): ${_Bank.getPrice(oraclePrice, 1 /* None */, true)}
+// src/services/group/utils/deserialize.utils.ts
+import { PublicKey as PublicKey24 } from "@solana/web3.js";
+function dtoToGroup(groupDto) {
+  return {
+    admin: new PublicKey24(groupDto.admin),
+    address: new PublicKey24(groupDto.address)
+  };
+}
 
-Config:
-- Asset weight init: ${this.config.assetWeightInit.toFixed(2)}
-- Asset weight maint: ${this.config.assetWeightMaint.toFixed(2)}
-- Liability weight init: ${this.config.liabilityWeightInit.toFixed(2)}
-- Liability weight maint: ${this.config.liabilityWeightMaint.toFixed(2)}
+// src/services/group/utils/serialize.utils.ts
+function groupToDto(group) {
+  return {
+    admin: group.admin.toBase58(),
+    address: group.address.toBase58()
+  };
+}
 
-- Deposit limit: ${this.config.depositLimit}
-- Borrow limit: ${this.config.borrowLimit}
+// src/services/native-stake/utils/deserialize.utils.ts
+import { PublicKey as PublicKey25 } from "@solana/web3.js";
+function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
+  return {
+    validator: new PublicKey25(validatorStakeGroupDto.validator),
+    poolKey: new PublicKey25(validatorStakeGroupDto.poolKey),
+    poolMintKey: new PublicKey25(validatorStakeGroupDto.poolMintKey),
+    totalStake: validatorStakeGroupDto.totalStake,
+    selectedAccount: {
+      pubkey: new PublicKey25(validatorStakeGroupDto.selectedAccount.pubkey),
+      amount: validatorStakeGroupDto.selectedAccount.amount
+    },
+    accounts: validatorStakeGroupDto.accounts.map((account) => ({
+      pubkey: new PublicKey25(account.pubkey),
+      amount: account.amount
+    }))
+  };
+}
 
-LTVs:
-- Initial: ${new BigNumber13(1).div(this.config.liabilityWeightInit).times(100).toFixed(2)}%
-- Maintenance: ${new BigNumber13(1).div(this.config.liabilityWeightMaint).times(100).toFixed(2)}%
-`;
-  }
-};
-var BankConfig = class _BankConfig {
-  constructor(assetWeightInit, assetWeightMaint, liabilityWeightInit, liabilityWeightMaint, depositLimit, borrowLimit, riskTier, totalAssetValueInitLimit, assetTag, oracleSetup, oracleKeys, oracleMaxAge, interestRateConfig, operationalState, oracleMaxConfidence, fixedPrice, configFlags) {
-    this.assetWeightInit = assetWeightInit;
-    this.assetWeightMaint = assetWeightMaint;
-    this.liabilityWeightInit = liabilityWeightInit;
-    this.liabilityWeightMaint = liabilityWeightMaint;
-    this.depositLimit = depositLimit;
-    this.borrowLimit = borrowLimit;
-    this.riskTier = riskTier;
-    this.totalAssetValueInitLimit = totalAssetValueInitLimit;
-    this.assetTag = assetTag;
-    this.oracleSetup = oracleSetup;
-    this.oracleKeys = oracleKeys;
-    this.oracleMaxAge = oracleMaxAge;
-    this.interestRateConfig = interestRateConfig;
-    this.operationalState = operationalState;
-    this.oracleMaxConfidence = oracleMaxConfidence;
-    this.fixedPrice = fixedPrice;
-    this.configFlags = configFlags;
+// src/services/native-stake/utils/fetch.utils.ts
+init_constants();
+init_single_spl_pool();
+import { LAMPORTS_PER_SOL as LAMPORTS_PER_SOL4, PublicKey as PublicKey26, StakeProgram as StakeProgram3 } from "@solana/web3.js";
+var fetchNativeStakeAccounts = async (connection, publicKey3, opts = {
+  filterInactive: true
+}) => {
+  if (!connection || !publicKey3) {
+    throw new Error("Invalid connection or public key");
   }
-  static fromAccountParsed(bankConfigRaw) {
-    const bankConfig = parseBankConfigRaw(bankConfigRaw);
-    return new _BankConfig(
-      bankConfig.assetWeightInit,
-      bankConfig.assetWeightMaint,
-      bankConfig.liabilityWeightInit,
-      bankConfig.liabilityWeightMaint,
-      bankConfig.depositLimit,
-      bankConfig.borrowLimit,
-      bankConfig.riskTier,
-      bankConfig.totalAssetValueInitLimit,
-      bankConfig.assetTag,
-      bankConfig.oracleSetup,
-      bankConfig.oracleKeys,
-      bankConfig.oracleMaxAge,
-      bankConfig.interestRateConfig,
-      bankConfig.operationalState,
-      bankConfig.oracleMaxConfidence,
-      bankConfig.fixedPrice,
-      bankConfig.configFlags
+  try {
+    const epochInfo = await connection.getEpochInfo();
+    const accounts = await connection.getParsedProgramAccounts(StakeProgram3.programId, {
+      filters: [
+        {
+          memcmp: {
+            offset: 12,
+            bytes: publicKey3.toBase58()
+          }
+        }
+      ]
+    });
+    const validatorMap = /* @__PURE__ */ new Map();
+    await Promise.all(
+      accounts.map(async (acc) => {
+        const parsedAccount = acc.account.data;
+        const stakeInfo = parsedAccount.parsed.info;
+        if (!stakeInfo.stake?.delegation || opts.filterInactive && (Number(stakeInfo.stake.delegation.activationEpoch) >= epochInfo.epoch || stakeInfo.stake.delegation.deactivationEpoch !== MAX_U64)) {
+          return;
+        }
+        const validatorAddress = stakeInfo.stake.delegation.voter;
+        const accountPubkey = acc.pubkey;
+        const amount = Number(stakeInfo.stake.delegation.stake) / LAMPORTS_PER_SOL4;
+        const existingAccounts = validatorMap.get(validatorAddress) || [];
+        validatorMap.set(validatorAddress, [...existingAccounts, { pubkey: accountPubkey, amount }]);
+      })
+    );
+    return Promise.all(
+      Array.from(validatorMap.entries()).map(async ([validatorAddress, accounts2]) => {
+        const poolKey = findPoolAddress(new PublicKey26(validatorAddress));
+        const poolMintKey = findPoolMintAddress(poolKey);
+        const totalStake = accounts2.reduce((acc, curr) => acc + curr.amount, 0);
+        const largestAccount = accounts2.reduce((acc, curr) => acc.amount > curr.amount ? acc : curr);
+        const sortedAccounts = accounts2.sort((a, b) => b.amount - a.amount);
+        if (!sortedAccounts[0].pubkey.equals(largestAccount.pubkey)) {
+          sortedAccounts.unshift(sortedAccounts.splice(sortedAccounts.indexOf(largestAccount), 1)[0]);
+        }
+        return {
+          validator: new PublicKey26(validatorAddress),
+          poolKey,
+          poolMintKey,
+          accounts: sortedAccounts,
+          totalStake,
+          selectedAccount: largestAccount
+        };
+      })
     );
+  } catch (e) {
+    console.error("Error getting stake accounts", e);
+    return [];
   }
 };
+var fetchStakePoolActiveStates = async (connection, validatorVoteAccounts) => {
+  const currentEpoch = await connection.getEpochInfo();
+  const activeStates = /* @__PURE__ */ new Map();
+  const poolMintAddressRecord = {};
+  const poolStakeAddressRecord = {};
+  validatorVoteAccounts.forEach((validatorVoteAccount) => {
+    const poolAddress = findPoolAddress(validatorVoteAccount);
+    const poolStakeAddress = findPoolStakeAddress(poolAddress);
+    const poolMintAddress = findPoolMintAddress(poolAddress);
+    poolMintAddressRecord[validatorVoteAccount.toBase58()] = poolMintAddress;
+    poolStakeAddressRecord[poolStakeAddress.toBase58()] = validatorVoteAccount;
+  });
+  const poolStakeAddressKeys = Object.keys(poolStakeAddressRecord);
+  const poolStakeAccounts = Object.fromEntries(
+    (await chunkedGetRawMultipleAccountInfoOrdered(connection, poolStakeAddressKeys)).map((ai, index) => [
+      poolStakeAddressRecord[poolStakeAddressKeys[index]],
+      ai?.data || null
+    ])
+  );
+  validatorVoteAccounts.forEach((validatorVoteAccount) => {
+    const stakeAccount = fetchStakeAccount(poolStakeAccounts[validatorVoteAccount.toBase58()]);
+    const poolMintAddress = poolMintAddressRecord[validatorVoteAccount.toBase58()];
+    if (!stakeAccount) {
+      activeStates.set(poolMintAddress.toBase58(), false);
+      return;
+    }
+    if (!stakeAccount.stake?.delegation) {
+      activeStates.set(poolMintAddress.toBase58(), false);
+      return;
+    }
+    const activationEpoch = stakeAccount.stake.delegation.activationEpoch;
+    const isActive = currentEpoch.epoch > Number(activationEpoch);
+    activeStates.set(validatorVoteAccount.toBase58(), isActive);
+  });
+  return activeStates;
+};
+var fetchStakeAccount = (data) => {
+  let offset = 0;
+  const discriminant = data.readUInt32LE(offset);
+  offset += 4;
+  const rentExemptReserve = data.readBigUInt64LE(offset);
+  offset += 8;
+  const staker = new PublicKey26(data.subarray(offset, offset + 32));
+  offset += 32;
+  const withdrawer = new PublicKey26(data.subarray(offset, offset + 32));
+  offset += 32;
+  const unixTimestamp = data.readBigUInt64LE(offset);
+  offset += 8;
+  const epoch = data.readBigUInt64LE(offset);
+  offset += 8;
+  const custodian = new PublicKey26(data.subarray(offset, offset + 32));
+  offset += 32;
+  const voterPubkey = new PublicKey26(data.subarray(offset, offset + 32));
+  offset += 32;
+  const stake = data.readBigUInt64LE(offset);
+  offset += 8;
+  const activationEpoch = data.readBigUInt64LE(offset);
+  offset += 8;
+  const deactivationEpoch = data.readBigUInt64LE(offset);
+  offset += 8;
+  const creditsObserved = data.readBigUInt64LE(offset);
+  return {
+    discriminant,
+    meta: {
+      rentExemptReserve,
+      authorized: {
+        staker,
+        withdrawer
+      },
+      lockup: {
+        unixTimestamp,
+        epoch,
+        custodian
+      }
+    },
+    stake: {
+      delegation: {
+        voterPubkey,
+        stake,
+        activationEpoch,
+        deactivationEpoch
+      },
+      creditsObserved
+    }
+  };
+};
+var fetchStakePoolMev = async (connection, validatorVoteAccounts) => {
+  const poolAddressRecord = {};
+  const poolStakeAddressRecord = {};
+  const onRampAddressRecord = {};
+  const mev = /* @__PURE__ */ new Map();
+  validatorVoteAccounts.forEach((validatorVoteAccount) => {
+    const poolAddress = findPoolAddress(validatorVoteAccount);
+    const poolStakeAddress = findPoolStakeAddress(poolAddress);
+    const onRampAddress = findPoolOnRampAddress(poolAddress);
+    poolAddressRecord[validatorVoteAccount.toBase58()] = poolAddress;
+    poolStakeAddressRecord[validatorVoteAccount.toBase58()] = poolStakeAddress;
+    onRampAddressRecord[validatorVoteAccount.toBase58()] = onRampAddress;
+  });
+  const poolStakeAddresses = validatorVoteAccounts.map(
+    (validatorVoteAccount) => poolStakeAddressRecord[validatorVoteAccount.toBase58()]
+  );
+  const onRampAddresses = validatorVoteAccounts.map(
+    (validatorVoteAccount) => onRampAddressRecord[validatorVoteAccount.toBase58()]
+  );
+  const allAddresses = [...poolStakeAddresses, ...onRampAddresses].map((address) => address.toBase58());
+  return chunkedGetRawMultipleAccountInfoOrdered(connection, allAddresses).then((accountInfos) => {
+    const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
+    const onRampInfos = accountInfos.slice(poolStakeAddresses.length);
+    const rent = 2282280;
+    validatorVoteAccounts.forEach((validatorVoteAccount, index) => {
+      const poolStakeInfo = poolStakeInfos[index];
+      const onRampInfo = onRampInfos[index];
+      if (poolStakeInfo && onRampInfo) {
+        const stakeDecoded = fetchStakeAccount(poolStakeInfo.data);
+        const onrampDecoded = fetchStakeAccount(onRampInfo.data);
+        const poolLamps = poolStakeInfo.lamports - rent - Number(stakeDecoded.stake.delegation.stake.toString());
+        const onrampStake = Number(onrampDecoded.stake.delegation.stake.toString());
+        mev.set(validatorVoteAccount.toBase58(), {
+          pool: poolLamps >= 1e3 ? poolLamps : 0,
+          onramp: onrampStake
+        });
+      }
+    });
+    return mev;
+  });
+};
+
+// src/services/native-stake/utils/serialize.utils.ts
+function validatorStakeGroupToDto(validatorStakeGroup) {
+  return {
+    validator: validatorStakeGroup.validator.toBase58(),
+    poolKey: validatorStakeGroup.poolKey.toBase58(),
+    poolMintKey: validatorStakeGroup.poolMintKey.toBase58(),
+    totalStake: validatorStakeGroup.totalStake,
+    selectedAccount: {
+      pubkey: validatorStakeGroup.selectedAccount.pubkey.toBase58(),
+      amount: validatorStakeGroup.selectedAccount.amount
+    },
+    accounts: validatorStakeGroup.accounts.map((account) => ({
+      pubkey: account.pubkey.toBase58(),
+      amount: account.amount
+    }))
+  };
+}
 
 // src/models/account/pure.ts
 var TOKEN_ACCOUNT_RENT_EXEMPT = 2039280;
@@ -26314,7 +26375,7 @@ var LendrAccount = class _LendrAccount {
     const useCache = false;
     const freeCollateral = useCache ? this.computeFreeCollateral().times(_volatilityFactor) : this.computeFreeCollateralLegacy(modifiedBanks, oraclePrices).times(_volatilityFactor);
     logger.debug({ freeCollateral: freeCollateral.toFixed(6) }, "[lendr:computeMaxBorrowForBank] Free collateral");
-    const untiedCollateralForBank = BigNumber14.min(
+    const untiedCollateralForBank = BigNumber15.min(
       bank.computeAssetUsdValue(priceInfo, balance.assetShares, 0 /* Initial */, 0 /* Lowest */),
       freeCollateral
     );
@@ -26350,7 +26411,7 @@ var LendrAccount = class _LendrAccount {
     const { liabilities: liabilitiesInit } = this.computeHealthComponents(0 /* Initial */);
     if (bank.config.riskTier === "Isolated" /* Isolated */ || initAssetWeight.isZero() && maintAssetWeight.isZero()) {
       if (freeCollateral.isZero() && !liabilitiesInit.isZero()) {
-        return new BigNumber14(0);
+        return new BigNumber15(0);
       } else {
         return entireBalance;
       }
@@ -26359,7 +26420,7 @@ var LendrAccount = class _LendrAccount {
       if (liabilitiesInit.eq(0)) {
         return entireBalance;
       } else if (freeCollateral.isZero()) {
-        return new BigNumber14(0);
+        return new BigNumber15(0);
       } else {
         const { liabilities: maintLiabilities, assets: maintAssets } = this.computeHealthComponents(
           1 /* Maintenance */
@@ -26476,7 +26537,7 @@ var LendrAccount = class _LendrAccount {
     );
     const assets = assetsAccount.minus(assetBank);
     const liabilities = liabilitiesAccount.minus(liabilitiesBank);
-    const amountBn = new BigNumber14(amount);
+    const amountBn = new BigNumber15(amount);
     let liquidationPrice;
     if (isLending) {
       if (liabilities.eq(0)) return null;
@@ -26519,7 +26580,7 @@ var LendrAccount = class _LendrAccount {
     const priceAssetLower = getPrice(assetPriceInfo, 0 /* Lowest */, false);
     const priceAssetMarket = getPrice(assetPriceInfo, 1 /* None */, false);
     const assetMaintWeight = assetBank.config.assetWeightMaint;
-    const liquidationDiscount = new BigNumber14(0.95);
+    const liquidationDiscount = new BigNumber15(0.95);
     const priceLiabHighest = getPrice(liabilityPriceInfo, 2 /* Highest */, false);
     const priceLiabMarket = getPrice(liabilityPriceInfo, 1 /* None */, false);
     const liabMaintWeight = liabilityBank.config.liabilityWeightMaint;
@@ -26556,7 +26617,7 @@ var LendrAccount = class _LendrAccount {
       },
       "[lendr:getMaxLiquidatableAssetAmount]"
     );
-    const maxLiquidatableUsdValue = BigNumber14.min(assetsUsdValue, underwaterMaintUsdValue, liabUsdValue);
+    const maxLiquidatableUsdValue = BigNumber15.min(assetsUsdValue, underwaterMaintUsdValue, liabUsdValue);
     logger.debug(
       {
         maxLiquidatableUsdValue: maxLiquidatableUsdValue.toFixed(6)
@@ -26618,7 +26679,7 @@ var LendrAccount = class _LendrAccount {
     }
     const depositIxs = [];
     if (bank.mint.equals(NATIVE_MINT2) && wrapAndUnwrapSol) {
-      depositIxs.push(...makeWrapSolIxs(this.authority, new BigNumber14(amount).minus(wSolBalanceUi)));
+      depositIxs.push(...makeWrapSolIxs(this.authority, new BigNumber15(amount).minus(wSolBalanceUi)));
     }
     return {
       depositIxs,
@@ -26683,7 +26744,7 @@ var LendrAccount = class _LendrAccount {
     const depositIx = await instructions_default.makeDepositWithSessionIx(program, accounts, ixArguments, remainingAccounts);
     if (bank.mint.equals(NATIVE_MINT2)) {
       const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
-      const wrapAmount = new BigNumber14(amount).minus(wSolBalanceUi);
+      const wrapAmount = new BigNumber15(amount).minus(wSolBalanceUi);
       const wrapIxs = makeSessionWrapSolIxs(session.walletPublicKey, session.sessionPublicKey, wrapAmount, {
         existingBalance: wSolBalanceUi
       });
@@ -26723,7 +26784,7 @@ var LendrAccount = class _LendrAccount {
       remainingAccounts.push(mintData.mint);
     }
     if (bank.mint.equals(NATIVE_MINT2) && wrapAndUnwrapSol) {
-      repayIxs.push(...makeWrapSolIxs(this.authority, new BigNumber14(amount).minus(wSolBalanceUi)));
+      repayIxs.push(...makeWrapSolIxs(this.authority, new BigNumber15(amount).minus(wSolBalanceUi)));
     }
     return {
       repayIxs,
@@ -26800,7 +26861,7 @@ var LendrAccount = class _LendrAccount {
     );
     if (bank.mint.equals(NATIVE_MINT2)) {
       const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
-      const neededAmount = new BigNumber14(amount).minus(wSolBalanceUi);
+      const neededAmount = new BigNumber15(amount).minus(wSolBalanceUi);
       const wrapIxs = makeSessionWrapSolIxs(session.walletPublicKey, session.sessionPublicKey, neededAmount, {
         existingBalance: wSolBalanceUi,
         wrapAmountUi: opts.wrapAmountUi
@@ -27240,8 +27301,8 @@ var LendrAccount = class _LendrAccount {
     }
     return projectedBalances.filter((b) => b.active).map((b) => b.bankPk);
   }
-  wrapInstructionForWSol(ix, amount = new BigNumber14(0)) {
-    return [...makeWrapSolIxs(this.authority, new BigNumber14(amount)), ix, makeUnwrapSolIx(this.authority)];
+  wrapInstructionForWSol(ix, amount = new BigNumber15(0)) {
+    return [...makeWrapSolIxs(this.authority, new BigNumber15(amount)), ix, makeUnwrapSolIx(this.authority)];
   }
   describe(banks, oraclePrices) {
     const { assets, liabilities } = this.computeHealthComponents(2 /* Equity */);
@@ -27303,7 +27364,7 @@ import {
   TransactionMessage as TransactionMessage5,
   VersionedTransaction as VersionedTransaction5
 } from "@solana/web3.js";
-import BigNumber15 from "bignumber.js";
+import BigNumber16 from "bignumber.js";
 init_constants();
 var LendrAccountWrapper = class _LendrAccountWrapper {
   // --------------------------------------------------------------------------
@@ -27316,9 +27377,23 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     this.client = client;
     this.address = lendrAccountPk;
     this._lendrAccount = lendrAccount;
+    this.banks = _LendrAccountWrapper.applyEmode(client.banks, lendrAccount);
   }
   address;
+  banks;
   _lendrAccount;
+  static applyEmode(banks, lendrAccount) {
+    const rawBanks = Array.from(banks.values());
+    const emodePairs = getEmodePairs(rawBanks);
+    const activePairs = lendrAccount.computeActiveEmodePairs(emodePairs);
+    if (activePairs.length === 0) return banks;
+    const { adjustedBanks } = adjustBanksWithEmode(rawBanks, activePairs);
+    const adjusted = /* @__PURE__ */ new Map();
+    for (const bank of adjustedBanks) {
+      adjusted.set(bank.address.toBase58(), bank);
+    }
+    return adjusted;
+  }
   static async fetch(lendrAccountPk, client, commitment) {
     const { config, program } = client;
     const _lendrAccountPk = translateAddress(lendrAccountPk);
@@ -27385,7 +27460,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   async simulateHealthCache() {
     const { lendrAccount: account } = await this._lendrAccount.simulateHealthCache(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       this.client.bankMetadataMap ?? {}
     );
@@ -27395,7 +27470,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     let { assets, liabilities } = this._lendrAccount.computeHealthComponents(1 /* Maintenance */);
     if (assets.isZero() && liabilities.isZero()) {
       const legacy = this._lendrAccount.computeHealthComponentsLegacy(
-        this.client.banks,
+        this.banks,
         this.client.oraclePrices,
         1 /* Maintenance */
       );
@@ -27428,7 +27503,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   // TODO)) migrate to computeHealthComponents
   computeHealthComponentsLegacy(lendrRequirement, excludedBanks = []) {
     return this._lendrAccount.computeHealthComponentsLegacy(
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       lendrRequirement,
       excludedBanks
@@ -27436,7 +27511,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   }
   computeHealthComponentsWithoutBiasLegacy(lendrRequirement) {
     return this._lendrAccount.computeHealthComponentsWithoutBiasLegacy(
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       lendrRequirement
     );
@@ -27445,7 +27520,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     return this._lendrAccount.computeFreeCollateral(opts);
   }
   computeFreeCollateralLegacy(opts) {
-    return this._lendrAccount.computeFreeCollateralLegacy(this.client.banks, this.client.oraclePrices, opts);
+    return this._lendrAccount.computeFreeCollateralLegacy(this.banks, this.client.oraclePrices, opts);
   }
   computeAccountValue() {
     return this._lendrAccount.computeAccountValue();
@@ -27456,12 +27531,12 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   computeEmodeImpacts(emodePairs) {
     return this._lendrAccount.computeEmodeImpacts(
       emodePairs,
-      Array.from(this.client.banks.keys()).map((b) => new PublicKey28(b))
+      Array.from(this.banks.keys()).map((b) => new PublicKey28(b))
     );
   }
   computeMaxBorrowForBank(bankAddress, opts) {
     return this._lendrAccount.computeMaxBorrowForBank(
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       bankAddress,
       opts,
@@ -27469,11 +27544,11 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     );
   }
   computeMaxWithdrawForBank(bankAddress, opts) {
-    return this._lendrAccount.computeMaxWithdrawForBank(this.client.banks, this.client.oraclePrices, bankAddress, opts);
+    return this._lendrAccount.computeMaxWithdrawForBank(this.banks, this.client.oraclePrices, bankAddress, opts);
   }
   computeMaxLiquidatableAssetAmount(assetBankAddress, liabilityBankAddress) {
     return this._lendrAccount.computeMaxLiquidatableAssetAmount(
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       assetBankAddress,
       liabilityBankAddress,
@@ -27481,11 +27556,11 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     );
   }
   computeLiquidationPriceForBank(bankAddress) {
-    return this._lendrAccount.computeLiquidationPriceForBank(this.client.banks, this.client.oraclePrices, bankAddress);
+    return this._lendrAccount.computeLiquidationPriceForBank(this.banks, this.client.oraclePrices, bankAddress);
   }
   computeLiquidationPriceForBankAmount(bankAddress, isLending, amount) {
     return this._lendrAccount.computeLiquidationPriceForBankAmount(
-      this.client.banks,
+      this.banks,
       this.client.oraclePrices,
       bankAddress,
       isLending,
@@ -27493,15 +27568,15 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     );
   }
   computeNetApy() {
-    return this._lendrAccount.computeNetApy(this.client.banks, this.client.oraclePrices);
+    return this._lendrAccount.computeNetApy(this.banks, this.client.oraclePrices);
   }
   /** Todo move this into client */
   computeLoopingParams(principal, targetLeverage, depositBankAddress, borrowBankAddress) {
-    const depositBank = this.client.banks.get(depositBankAddress.toBase58());
+    const depositBank = this.banks.get(depositBankAddress.toBase58());
     if (!depositBank) throw Error(`Bank ${depositBankAddress.toBase58()} not found`);
     const depositPriceInfo = this.client.oraclePrices.get(depositBankAddress.toBase58());
     if (!depositPriceInfo) throw Error(`Price info for ${depositBankAddress.toBase58()} not found`);
-    const borrowBank = this.client.banks.get(borrowBankAddress.toBase58());
+    const borrowBank = this.banks.get(borrowBankAddress.toBase58());
     if (!borrowBank) throw Error(`Bank ${borrowBankAddress.toBase58()} not found`);
     const borrowPriceInfo = this.client.oraclePrices.get(borrowBankAddress.toBase58());
     if (!borrowPriceInfo) throw Error(`Price info for ${borrowBankAddress.toBase58()} not found`);
@@ -27798,9 +27873,9 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
       },
       "[lendr:lendr-account:loop] Looping into Lendr account"
     );
-    const depositBank = this.client.banks.get(props.depositBankAddress.toBase58());
+    const depositBank = this.banks.get(props.depositBankAddress.toBase58());
     if (!depositBank) throw Error("Deposit bank not found");
-    const borrowBank = this.client.banks.get(props.borrowBankAddress.toBase58());
+    const borrowBank = this.banks.get(props.borrowBankAddress.toBase58());
     if (!borrowBank) throw Error("Borrow bank not found");
     const { processOpts, txOpts, ...txProps } = props;
     const { transactions } = await this.makeLoopTxV2(txProps);
@@ -27825,9 +27900,9 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     setupBankAddresses,
     overrideInferAccounts
   }) {
-    const depositBank = this.client.banks.get(depositBankAddress.toBase58());
+    const depositBank = this.banks.get(depositBankAddress.toBase58());
     if (!depositBank) throw Error("Deposit bank not found");
-    const borrowBank = this.client.banks.get(borrowBankAddress.toBase58());
+    const borrowBank = this.banks.get(borrowBankAddress.toBase58());
     if (!borrowBank) throw Error("Borrow bank not found");
     const blockhash = blockhashArg ?? (await this._program.provider.connection.getLatestBlockhash("confirmed")).blockhash;
     const setupIxs = await this.makeSetupIx(setupBankAddresses ?? [borrowBankAddress, depositBankAddress]);
@@ -27851,7 +27926,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     let flashloanTx;
     let txOverflown = false;
     if (depositBank.mint.equals(NATIVE_MINT3) && inputDepositAmount) {
-      setupIxs.push(...makeWrapSolIxs(this.authority, new BigNumber15(inputDepositAmount)));
+      setupIxs.push(...makeWrapSolIxs(this.authority, new BigNumber16(inputDepositAmount)));
     }
     if (setupIxs.length > 0) {
       const message = new TransactionMessage5({
@@ -27968,7 +28043,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   async makeDepositIx(amount, bankAddress, depositOpts = {}) {
     return this._lendrAccount.makeDepositIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       amount,
       bankAddress,
@@ -27978,7 +28053,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   async makeDepositWithSessionIx(amount, bankAddress, session, depositOpts = {}) {
     return this._lendrAccount.makeDepositWithSessionIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       amount,
       bankAddress,
@@ -28224,7 +28299,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     const ldrAccount = LendrAccount.decode(ldrAccountData, this._program.idl);
     console.log("ldrAccount", ldrAccount);
     if (!bankData) throw new Error("Failed to simulate");
-    const previewBanks = new Map(this.client.banks);
+    const previewBanks = new Map(this.banks);
     banksToInspect.forEach((bankAddress, idx) => {
       const data = bankData[idx];
       if (!data) throw new Error("Failed to simulate");
@@ -28239,7 +28314,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
       wallet: {},
       isReadOnly: true,
       group: this.client.group,
-      banks: this.client.banks,
+      banks: previewBanks,
       priceInfos: this.client.oraclePrices,
       mintDatas: this.client.mintDatas,
       feedIdMap: this.client.feedIdMap,
@@ -28271,7 +28346,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!tokenProgramAddress) throw Error("Repay mint not found");
     return this._lendrAccount.makeRepayIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       amount,
       bankAddress,
@@ -28295,7 +28370,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!tokenProgramAddress) throw Error("Repay mint not found");
     return this._lendrAccount.makeRepayWithSessionIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       amount,
       bankAddress,
@@ -28424,7 +28499,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
     return this._lendrAccount.makeWithdrawIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       this.client.bankMetadataMap,
       amount,
@@ -28450,7 +28525,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
     return this._lendrAccount.makeWithdrawWithSessionIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       this.client.bankMetadataMap,
       amount,
@@ -28487,7 +28562,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     const mintAuthority = findPoolMintAuthorityAddress(pool);
     const lstAta = getAssociatedTokenAddressSync3(lstMint, this.authority);
     const rentExemption = await this._program.provider.connection.getMinimumBalanceForRentExemption(200);
-    const stakeAmount = new BigNumber15(new BigNumber15(amount).toString());
+    const stakeAmount = new BigNumber16(new BigNumber16(amount).toString());
     const withdrawIxs = await this.makeWithdrawIx(amount, bankAddress, isWholePosition, {
       createAtas: true,
       wrapAndUnwrapSol: true
@@ -28768,7 +28843,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
     return this._lendrAccount.makeBorrowIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       this.client.bankMetadataMap,
       amount,
@@ -28791,7 +28866,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
     return this._lendrAccount.makeBorrowWithSessionIx(
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       this.client.bankMetadataMap,
       amount,
@@ -28963,12 +29038,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
    * @returns An InstructionsWrapper containing the withdraw emissions instructions
    */
   async makeWithdrawEmissionsIx(bankAddress) {
-    return this._lendrAccount.makeWithdrawEmissionsIx(
-      this._program,
-      this.client.banks,
-      this.client.mintDatas,
-      bankAddress
-    );
+    return this._lendrAccount.makeWithdrawEmissionsIx(this._program, this.banks, this.client.mintDatas, bankAddress);
   }
   /**
    * Creates a versioned transaction for withdrawing emissions rewards from multiple lendr bank accounts.
@@ -29045,7 +29115,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     return this._lendrAccount.makeLendingAccountLiquidateIx(
       liquidateeLendrAccount,
       this._program,
-      this.client.banks,
+      this.banks,
       this.client.mintDatas,
       this.client.bankMetadataMap,
       assetBankAddress,
@@ -29118,7 +29188,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
    * @returns An InstructionsWrapper containing the end flash loan instruction
    */
   async makeEndFlashLoanIx(projectedActiveBalances) {
-    return this._lendrAccount.makeEndFlashLoanIx(this._program, this.client.banks, projectedActiveBalances);
+    return this._lendrAccount.makeEndFlashLoanIx(this._program, this.banks, projectedActiveBalances);
   }
   /**
    * Creates an instruction to end a flash loan operation.
@@ -29130,7 +29200,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   async makeEndFlashLoanWithSessionIx(projectedActiveBalances, session) {
     return this._lendrAccount.makeEndFlashLoanWithSessionIx(
       this._program,
-      this.client.banks,
+      this.banks,
       projectedActiveBalances,
       session.sessionPublicKey
     );
@@ -29231,7 +29301,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   async makePulseHealthIx(mandatoryBanks = [], excludedBanks = []) {
     return this._lendrAccount.makePulseHealthIx(
       this._program,
-      this.client.banks,
+      this.banks,
       mandatoryBanks,
       excludedBanks,
       this.client.bankMetadataMap || {}
@@ -29268,9 +29338,10 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
   }
   _updateFromAccountParsed(data) {
     this._lendrAccount = LendrAccount.fromAccountParsed(this.address, data);
+    this.banks = _LendrAccountWrapper.applyEmode(this.client.banks, this._lendrAccount);
   }
   describe() {
-    return this._lendrAccount.describe(this.client.banks, this.client.oraclePrices);
+    return this._lendrAccount.describe(this.banks, this.client.oraclePrices);
   }
   // --------------------------------------------------------------------------
   // DEPRECATED METHODS
@@ -29325,7 +29396,7 @@ var LendrAccountWrapper = class _LendrAccountWrapper {
     const simulation = await this.client.simulateTransactions([tx], [this._lendrAccount.address]);
     const rawBuffer = simulation[0];
     if (!rawBuffer) {
-      return new BigNumber15(0);
+      return new BigNumber16(0);
     }
     const simulatedLendrAccount = LendrAccount.fromAccountDataRaw(this.address, rawBuffer, this.client.program.idl);
     const outstandingEmissions = simulatedLendrAccount.getBalance(bank).emissionsOutstanding;
@@ -29917,7 +29988,7 @@ var LendrClient = class _LendrClient {
       const oracle = priceInfos.get(bankAddress.toBase58());
       if (oracle) {
         const adjustPrice = (price, stakeActual2, tokenSupply2) => {
-          return Number(tokenSupply2) === 0 ? price : new BigNumber16(price.toNumber() * (stakeActual2 - LAMPORTS_PER_SOL6) / Number(tokenSupply2));
+          return Number(tokenSupply2) === 0 ? price : new BigNumber17(price.toNumber() * (stakeActual2 - LAMPORTS_PER_SOL6) / Number(tokenSupply2));
         };
         const adjustPriceComponent2 = (priceComponent, stakeActual2, tokenSupply2) => ({
           price: adjustPrice(priceComponent.price, stakeActual2, tokenSupply2),
@@ -30658,6 +30729,7 @@ export {
   WSOL_MINT,
   accountFlagToBN,
   addOracleToBanksIx,
+  adjustBanksWithEmode,
   balanceToDto,
   bankConfigRawToDto,
   bankConfigToBankConfigRaw,
@@ -30737,6 +30809,7 @@ export {
   getBankVaultSeeds,
   getConfig,
   getConfigPda,
+  getEmodePairs,
   getHealthCacheStatusDescription,
   getLiabilityQuantity,
   getLiabilityShares,
@@ -30759,6 +30832,7 @@ export {
   lendrAccountToDto,
   makeAddPermissionlessStakedBankIx,
   makeBundleTipIx,
+  makeEmodeAssetWeights,
   makePoolAddBankIx2 as makePoolAddBankIx,
   makePoolConfigureBankIx2 as makePoolConfigureBankIx,
   makePriorityFeeIx,