@0dotxyz/p0-ts-sdk 2.2.0-alpha.5 → 2.2.0-alpha.7

package/dist/index.js

@@ -1,4 +1,4 @@
-import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, Transaction, StakeProgram, Keypair, StakeAuthorizationLayout, AddressLookupTableAccount, SYSVAR_RENT_PUBKEY, TransactionInstruction, LAMPORTS_PER_SOL, SYSVAR_INSTRUCTIONS_PUBKEY, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1 } from '@solana/web3.js';
+import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, Transaction, AddressLookupTableAccount, SYSVAR_RENT_PUBKEY, StakeProgram, TransactionInstruction, LAMPORTS_PER_SOL, Keypair, StakeAuthorizationLayout, SYSVAR_INSTRUCTIONS_PUBKEY, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1 } from '@solana/web3.js';
 import { object, string, enums, array, assert } from 'superstruct';
 import BigNumber3, { BigNumber } from 'bignumber.js';
 import BN11, { BN } from 'bn.js';
@@ -91,10 +91,9 @@ function getConfig(environment = "production", overrides) {
 
 // src/errors/transaction-building.errors.ts
 var TransactionBuildingErrorCode = /* @__PURE__ */ ((TransactionBuildingErrorCode2) => {
-  TransactionBuildingErrorCode2["JUPITER_SWAP_SIZE_EXCEEDED_REPAY"] = "JUPITER_SWAP_SIZE_EXCEEDED_REPAY";
-  TransactionBuildingErrorCode2["JUPITER_SWAP_SIZE_EXCEEDED_LOOP"] = "JUPITER_SWAP_SIZE_EXCEEDED_LOOP";
   TransactionBuildingErrorCode2["SWAP_SIZE_EXCEEDED_LOOP"] = "SWAP_SIZE_EXCEEDED_LOOP";
   TransactionBuildingErrorCode2["SWAP_SIZE_EXCEEDED_REPAY"] = "SWAP_SIZE_EXCEEDED_REPAY";
+  TransactionBuildingErrorCode2["SWAP_SIZE_EXCEEDED_POSITION_SWAP"] = "SWAP_SIZE_EXCEEDED_POSITION_SWAP";
   TransactionBuildingErrorCode2["ORACLE_CRANK_FAILED"] = "ORACLE_CRANK_FAILED";
   TransactionBuildingErrorCode2["KAMINO_RESERVE_NOT_FOUND"] = "KAMINO_RESERVE_NOT_FOUND";
   TransactionBuildingErrorCode2["DRIFT_STATE_NOT_FOUND"] = "DRIFT_STATE_NOT_FOUND";
@@ -115,23 +114,6 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       Error.captureStackTrace(this, _TransactionBuildingError);
     }
   }
-  /**
-   * Jupiter swap instruction size exceeds available transaction size
-   */
-  static jupiterSwapSizeExceededLoop(bytes, accountKeys) {
-    return new _TransactionBuildingError(
-      "JUPITER_SWAP_SIZE_EXCEEDED_LOOP" /* JUPITER_SWAP_SIZE_EXCEEDED_LOOP */,
-      "Jupiter swap instruction size exceeds available transaction size",
-      { bytes, accountKeys }
-    );
-  }
-  static jupiterSwapSizeExceededRepay(bytes, accountKeys) {
-    return new _TransactionBuildingError(
-      "JUPITER_SWAP_SIZE_EXCEEDED_REPAY" /* JUPITER_SWAP_SIZE_EXCEEDED_REPAY */,
-      "Jupiter swap instruction size exceeds available transaction size",
-      { bytes, accountKeys }
-    );
-  }
   static swapSizeExceededLoop(bytes, accountKeys, provider) {
     return new _TransactionBuildingError(
       "SWAP_SIZE_EXCEEDED_LOOP" /* SWAP_SIZE_EXCEEDED_LOOP */,
@@ -146,6 +128,13 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { bytes, accountKeys, provider }
     );
   }
+  static swapSizeExceededPositionSwap(bytes, accountKeys, provider) {
+    return new _TransactionBuildingError(
+      "SWAP_SIZE_EXCEEDED_POSITION_SWAP" /* SWAP_SIZE_EXCEEDED_POSITION_SWAP */,
+      `${provider ?? "Swap"} instruction size exceeds available transaction size`,
+      { bytes, accountKeys, provider }
+    );
+  }
   /**
    * Failed to crank oracles for one or more banks
    */
@@ -44358,12 +44347,28 @@ var V1Client = class _V1Client {
     return new Promise((resolve, reject) => {
       const ws = new WebSocket(url, [SUBPROTOCOL]);
       ws.binaryType = "arraybuffer";
-      ws.on("open", () => {
+      const onOpen = () => {
+        ws.off("error", onError);
+        ws.off("close", onClose);
         resolve(new _V1Client(ws));
-      });
-      ws.on("error", (err) => {
+      };
+      const onError = (err) => {
+        ws.off("open", onOpen);
+        ws.off("close", onClose);
         reject(err);
-      });
+      };
+      const onClose = (code, reason) => {
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        reject(
+          new Error(
+            `WebSocket closed before open (code=${code}${reason.length ? `, reason=${reason.toString()}` : ""})`
+          )
+        );
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+      ws.once("close", onClose);
     });
   }
   // --- Constructor ---
@@ -46903,6 +46908,444 @@ async function makeJuplendDepositTx(params) {
   });
   return solanaTx;
 }
+async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
+  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
+    program.programId,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { endIndex: new BN11(endIndex) }
+  ) : await instructions_default.makeBeginFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { endIndex: new BN11(endIndex) }
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
+  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
+    program.programId,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  ) : await instructions_default.makeEndFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function makeFlashLoanTx({
+  program,
+  marginfiAccount,
+  ixs,
+  bankMap,
+  blockhash,
+  addressLookupTableAccounts,
+  signers,
+  isSync
+}) {
+  const endIndex = ixs.length + 1;
+  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
+    marginfiAccount.balances,
+    ixs,
+    program
+  );
+  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
+    const b = bankMap.get(account.toBase58());
+    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
+    return b;
+  });
+  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    endIndex,
+    marginfiAccount.authority,
+    isSync
+  );
+  const endFlashLoanIx = await makeEndFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    projectedActiveBanks,
+    marginfiAccount.authority,
+    isSync
+  );
+  const message = new TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: blockhash,
+    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
+  }).compileToV0Message(addressLookupTableAccounts);
+  const tx = addTransactionMetadata(new VersionedTransaction(message), {
+    addressLookupTables: addressLookupTableAccounts,
+    type: "FLASHLOAN" /* FLASHLOAN */,
+    signers
+  });
+  if (signers) {
+    tx.sign(signers);
+  }
+  return tx;
+}
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    bankMap,
+    depositOpts,
+    borrowOpts,
+    bankMetadataMap,
+    addressLookupTableAccounts,
+    connection,
+    oraclePrices,
+    crossbarUrl,
+    additionalIxs = []
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      {
+        mint: borrowOpts.borrowBank.mint,
+        tokenProgram: borrowOpts.tokenProgram
+      },
+      {
+        mint: depositOpts.depositBank.mint,
+        tokenProgram: depositOpts.tokenProgram
+      }
+    ]
+  });
+  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
+  );
+  const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
+  );
+  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
+    bankMetadataMap
+  );
+  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
+    setupIxs.push(
+      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber(depositOpts.inputDepositAmount))
+    );
+  }
+  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
+    const ixs = [
+      ...additionalIxs,
+      ...setupIxs,
+      ...kaminoRefreshIxs.instructions,
+      ...updateDriftMarketIxs.instructions,
+      ...updateJupLendRateIxs.instructions
+    ];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildLoopFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  borrowOpts,
+  depositOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  swapOpts,
+  overrideInferAccounts,
+  blockhash
+}) {
+  const cuRequestIxs = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
+  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
+    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
+  } else {
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      new PublicKey(depositOpts.depositBank.mint),
+      marginfiAccount.authority,
+      true,
+      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+    );
+    const swapConstraints = await computeFlashloanSwapConstraints({
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+      primaryIx: {
+        type: "borrow",
+        bank: borrowOpts.borrowBank,
+        tokenProgram: borrowOpts.tokenProgram
+      },
+      secondaryIx: {
+        type: "deposit",
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram
+      },
+      overrideInferAccounts
+    });
+    const swapResponse = await getSwapIxsForFlashloan({
+      inputMint: borrowOpts.borrowBank.mint.toBase58(),
+      outputMint: depositOpts.depositBank.mint.toBase58(),
+      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
+      swapMode: "ExactIn",
+      authority: marginfiAccount.authority,
+      connection,
+      destinationTokenAccount,
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
+    });
+    sizeConstraintUsed = swapConstraints.sizeConstraint;
+    const outAmountThreshold = nativeToUi(
+      swapResponse.quoteResponse.otherAmountThreshold,
+      depositOpts.depositBank.mintDecimals
+    );
+    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
+    swapInstructions = swapResponse.swapInstructions;
+    setupInstructions = swapResponse.setupInstructions;
+    swapLookupTables = swapResponse.addressLookupTableAddresses;
+    swapQuote = swapResponse.quoteResponse;
+  }
+  const borrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowOpts.borrowBank,
+    bankMap,
+    tokenProgram: borrowOpts.tokenProgram,
+    amount: borrowOpts.borrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: false,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
+  });
+  let depositIxs;
+  switch (depositOpts.depositBank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
+        );
+      }
+      depositIxs = await makeKaminoDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
+        );
+      }
+      const driftMarketIndex = driftState.spotMarketState.marketIndex;
+      const driftOracle = driftState.spotMarketState.oracle;
+      depositIxs = await makeDriftDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        driftMarketIndex,
+        driftOracle,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    case 6 /* JUPLEND */: {
+      depositIxs = await makeJuplendDepositIx2({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    default: {
+      depositIxs = await makeDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+  }
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...swapInstructions,
+    ...depositIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint: sizeConstraintUsed,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
+  }
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededLoop(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    borrowIxs,
+    depositIxs,
+    amountToDeposit
+  };
+}
 async function makeRepayIx3({
   program,
   bank,
@@ -47357,882 +47800,6 @@ async function buildRepayWithCollatFlashloanTx({
   };
 }
 
-// src/services/account/utils/flashloan-size.utils.ts
-var SWAP_MERGE_OVERHEAD = 150;
-var FL_IX_OVERHEAD = 52;
-function compactU16Size(n) {
-  return n < 128 ? 1 : n < 16384 ? 2 : 3;
-}
-function computeV0TxSize(ixs, payerKey, luts) {
-  const keyMap = /* @__PURE__ */ new Map();
-  const payerStr = payerKey.toBase58();
-  keyMap.set(payerStr, { isSigner: true, isWritable: true });
-  const programIds = /* @__PURE__ */ new Set();
-  for (const ix of ixs) {
-    const progStr = ix.programId.toBase58();
-    programIds.add(progStr);
-    if (!keyMap.has(progStr)) {
-      keyMap.set(progStr, { isSigner: false, isWritable: false });
-    }
-    for (const meta of ix.keys) {
-      const keyStr = meta.pubkey.toBase58();
-      const existing = keyMap.get(keyStr);
-      if (existing) {
-        existing.isSigner = existing.isSigner || meta.isSigner;
-        existing.isWritable = existing.isWritable || meta.isWritable;
-      } else {
-        keyMap.set(keyStr, { isSigner: meta.isSigner, isWritable: meta.isWritable });
-      }
-    }
-  }
-  const lutLookup = /* @__PURE__ */ new Map();
-  for (let li = 0; li < luts.length; li++) {
-    const addresses = luts[li].state.addresses;
-    for (let ai = 0; ai < addresses.length; ai++) {
-      const addrStr = addresses[ai].toBase58();
-      if (!lutLookup.has(addrStr)) {
-        lutLookup.set(addrStr, { lutIdx: li, addrIdx: ai });
-      }
-    }
-  }
-  let numStaticKeys = 0;
-  let numWritableStaticKeys = 0;
-  const lutWritableIdxs = luts.map(() => /* @__PURE__ */ new Set());
-  const lutReadonlyIdxs = luts.map(() => /* @__PURE__ */ new Set());
-  for (const [keyStr, props] of keyMap) {
-    if (props.isSigner || programIds.has(keyStr)) {
-      numStaticKeys++;
-      if (props.isWritable) numWritableStaticKeys++;
-      continue;
-    }
-    const lutEntry = lutLookup.get(keyStr);
-    if (lutEntry) {
-      if (props.isWritable) {
-        lutWritableIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
-      } else {
-        lutReadonlyIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
-      }
-    } else {
-      numStaticKeys++;
-      if (props.isWritable) numWritableStaticKeys++;
-    }
-  }
-  const fixedOverhead = 101;
-  const staticKeysSection = compactU16Size(numStaticKeys) + numStaticKeys * 32;
-  let ixSection = compactU16Size(ixs.length);
-  for (const ix of ixs) {
-    const numAccounts = ix.keys.length;
-    ixSection += 1 + // programId index
-    compactU16Size(numAccounts) + numAccounts + // account key indexes
-    compactU16Size(ix.data.length) + ix.data.length;
-  }
-  let numUsedLuts = 0;
-  let lutSection = 0;
-  for (let li = 0; li < luts.length; li++) {
-    const wCount = lutWritableIdxs[li].size;
-    const rCount = lutReadonlyIdxs[li].size;
-    if (wCount === 0 && rCount === 0) continue;
-    numUsedLuts++;
-    lutSection += 32 + // LUT address
-    compactU16Size(wCount) + wCount + // writable indexes
-    compactU16Size(rCount) + rCount;
-  }
-  lutSection += compactU16Size(numUsedLuts);
-  let totalLutKeys = 0;
-  for (let li = 0; li < luts.length; li++) {
-    totalLutKeys += lutWritableIdxs[li].size + lutReadonlyIdxs[li].size;
-  }
-  const accountCount = numStaticKeys + totalLutKeys;
-  let totalLutWritableKeys = 0;
-  for (let li = 0; li < luts.length; li++) {
-    totalLutWritableKeys += lutWritableIdxs[li].size;
-  }
-  const writableAccountCount = numWritableStaticKeys + totalLutWritableKeys;
-  const size = fixedOverhead + staticKeysSection + ixSection + lutSection + 1;
-  return { size, accountCount, writableAccountCount };
-}
-function computeFlashLoanNonSwapBudget({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  addressLookupTableAccounts
-}) {
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((key) => {
-    const b = bankMap.get(key.toBase58());
-    if (!b) throw new Error(`Bank ${key.toBase58()} not found in computeFlashLoanNonSwapBudget`);
-    return b;
-  });
-  const endIndex = ixs.length + 1;
-  const beginFlIx = sync_instructions_default.makeBeginFlashLoanIx(
-    program.programId,
-    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
-    { endIndex: new BN11(endIndex) }
-  );
-  const endFlRemainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
-  const endFlIx = sync_instructions_default.makeEndFlashLoanIx(
-    program.programId,
-    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
-    endFlRemainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false }))
-  );
-  const allNonSwapIxs = [beginFlIx, ...ixs, endFlIx];
-  const nonSwapMsg = new TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: PublicKey.default.toBase58(),
-    instructions: allNonSwapIxs
-  }).compileToV0Message(addressLookupTableAccounts);
-  const nonSwapSize = new VersionedTransaction(nonSwapMsg).serialize().length;
-  const { header, staticAccountKeys, addressTableLookups } = nonSwapMsg;
-  const nonSwapTotal = staticAccountKeys.length + addressTableLookups.reduce(
-    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
-    0
-  );
-  const sizeConstraint = MAX_TX_SIZE - nonSwapSize - SWAP_MERGE_OVERHEAD;
-  const maxSwapTotalAccounts = MAX_ACCOUNT_LOCKS - nonSwapTotal;
-  console.log("[flashloan-budget]", {
-    method: "compiled",
-    nonSwapSize,
-    nonSwapTotal,
-    sizeConstraint,
-    maxSwapTotalAccounts
-  });
-  return { sizeConstraint, maxSwapTotalAccounts };
-}
-function compileFlashloanPrecheck({
-  allIxs,
-  payer,
-  luts,
-  sizeConstraint,
-  swapIxCount,
-  swapLutCount
-}) {
-  const msg = new TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: PublicKey.default.toBase58(),
-    instructions: allIxs
-  }).compileToV0Message(luts);
-  const rawSize = new VersionedTransaction(msg).serialize().length;
-  const fullTxSize = rawSize + FL_IX_OVERHEAD;
-  const overshoot = fullTxSize - MAX_TX_SIZE;
-  const { header, staticAccountKeys, addressTableLookups } = msg;
-  const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
-  const writableLut = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
-  const writableAccounts = writableStatic + writableLut;
-  const totalAccounts = staticAccountKeys.length + addressTableLookups.reduce(
-    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
-    0
-  );
-  console.log("[flashloan-precheck]", {
-    fullTxSize,
-    overshoot,
-    sizeConstraint,
-    writableAccounts,
-    totalAccounts,
-    staticKeys: staticAccountKeys.length,
-    numLuts: addressTableLookups.length,
-    swapIxCount,
-    swapLutCount
-  });
-  return { fullTxSize, overshoot, writableAccounts, totalAccounts };
-}
-async function buildBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  switch (config.type) {
-    case "borrow":
-      return makeBorrowIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        isSync: true,
-        opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
-      });
-    case "repay":
-      return makeRepayIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        repayAll: false,
-        isSync: true,
-        opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
-      });
-    case "deposit":
-      return buildDepositBudgetIx(
-        config,
-        program,
-        marginfiAccount,
-        bankMetadataMap,
-        overrideInferAccounts
-      );
-    case "withdraw":
-      return buildWithdrawBudgetIx(
-        config,
-        program,
-        marginfiAccount,
-        bankMap,
-        bankMetadataMap,
-        overrideInferAccounts
-      );
-  }
-}
-async function buildDepositBudgetIx(config, program, marginfiAccount, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  const opts = { wrapAndUnwrapSol: false, overrideInferAccounts };
-  switch (bank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeKaminoDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        reserve,
-        isSync: true,
-        opts
-      });
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeDriftDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex: driftState.spotMarketState.marketIndex,
-        driftOracle: driftState.spotMarketState.oracle,
-        isSync: true,
-        opts
-      });
-    }
-    case 6 /* JUPLEND */: {
-      return makeJuplendDepositIx2({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        isSync: true,
-        opts
-      });
-    }
-    default: {
-      return makeDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        isSync: true,
-        opts
-      });
-    }
-  }
-}
-async function buildWithdrawBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  const opts = { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts };
-  switch (bank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeKaminoWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        cTokenAmount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        reserve,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeDriftWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        driftSpotMarket: driftState.spotMarketState,
-        userRewards: driftState.userRewards,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-    case 6 /* JUPLEND */: {
-      const jupLendState = bankMetadataMap[bank.address.toBase58()]?.jupLendStates;
-      if (!jupLendState) {
-        throw TransactionBuildingError.jupLendStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeJuplendWithdrawIx2({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: false,
-        opts
-      });
-    }
-    default: {
-      return makeWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-  }
-}
-async function computeFlashloanSwapConstraints({
-  program,
-  marginfiAccount,
-  bankMap,
-  addressLookupTableAccounts,
-  bankMetadataMap,
-  primaryIx,
-  secondaryIx,
-  overrideInferAccounts
-}) {
-  const cuRequestIxs = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  const [primaryResult, secondaryResult] = await Promise.all([
-    buildBudgetIx(
-      primaryIx,
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      overrideInferAccounts
-    ),
-    buildBudgetIx(
-      secondaryIx,
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      overrideInferAccounts
-    )
-  ]);
-  return computeFlashLoanNonSwapBudget({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts,
-    ixs: [...cuRequestIxs, ...primaryResult.instructions, ...secondaryResult.instructions]
-  });
-}
-
-// src/services/account/actions/flash-loan.ts
-async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
-  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
-    program.programId,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    { endIndex: new BN11(endIndex) }
-  ) : await instructions_default.makeBeginFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    { endIndex: new BN11(endIndex) }
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
-  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
-  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
-    program.programId,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  ) : await instructions_default.makeEndFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function makeFlashLoanTx({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  blockhash,
-  addressLookupTableAccounts,
-  signers,
-  isSync
-}) {
-  const endIndex = ixs.length + 1;
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
-    const b = bankMap.get(account.toBase58());
-    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
-    return b;
-  });
-  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    endIndex,
-    marginfiAccount.authority,
-    isSync
-  );
-  const endFlashLoanIx = await makeEndFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    projectedActiveBanks,
-    marginfiAccount.authority,
-    isSync
-  );
-  const message = new TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: blockhash,
-    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
-  }).compileToV0Message(addressLookupTableAccounts);
-  const tx = addTransactionMetadata(new VersionedTransaction(message), {
-    addressLookupTables: addressLookupTableAccounts,
-    type: "FLASHLOAN" /* FLASHLOAN */,
-    signers
-  });
-  if (signers) {
-    tx.sign(signers);
-  }
-  return tx;
-}
-
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    bankMap,
-    depositOpts,
-    borrowOpts,
-    bankMetadataMap,
-    addressLookupTableAccounts,
-    connection,
-    oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
-  } = params;
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      {
-        mint: borrowOpts.borrowBank.mint,
-        tokenProgram: borrowOpts.tokenProgram
-      },
-      {
-        mint: depositOpts.depositBank.mint,
-        tokenProgram: depositOpts.tokenProgram
-      }
-    ]
-  });
-  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
-  );
-  const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
-  );
-  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
-    marginfiAccount,
-    bankMap,
-    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
-    bankMetadataMap
-  );
-  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
-    ...params,
-    blockhash
-  });
-  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
-    if (ix.programId.equals(ComputeBudgetProgram.programId)) {
-      return false;
-    }
-    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
-        return false;
-      }
-    }
-    return true;
-  });
-  setupIxs.push(...jupiterSetupInstructions);
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  let additionalTxs = [];
-  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
-    setupIxs.push(
-      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber(depositOpts.inputDepositAmount))
-    );
-  }
-  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
-    const ixs = [
-      ...additionalIxs,
-      ...setupIxs,
-      ...kaminoRefreshIxs.instructions,
-      ...updateDriftMarketIxs.instructions,
-      ...updateJupLendRateIxs.instructions
-    ];
-    const txs = splitInstructionsToFitTransactions([], ixs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
-    );
-  }
-  if (updateFeedIxs.length > 0) {
-    const message = new TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
-    );
-  }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildLoopFlashloanTx({
-  program,
-  marginfiAccount,
-  bankMap,
-  borrowOpts,
-  depositOpts,
-  bankMetadataMap,
-  addressLookupTableAccounts,
-  connection,
-  swapOpts,
-  overrideInferAccounts,
-  blockhash
-}) {
-  const cuRequestIxs = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  let amountToDeposit;
-  let swapInstructions = [];
-  let setupInstructions = [];
-  let swapLookupTables = [];
-  let swapQuote;
-  let sizeConstraintUsed = 0;
-  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
-    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
-  } else {
-    const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new PublicKey(depositOpts.depositBank.mint),
-      marginfiAccount.authority,
-      true,
-      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
-    );
-    const swapConstraints = await computeFlashloanSwapConstraints({
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
-      primaryIx: {
-        type: "borrow",
-        bank: borrowOpts.borrowBank,
-        tokenProgram: borrowOpts.tokenProgram
-      },
-      secondaryIx: {
-        type: "deposit",
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram
-      },
-      overrideInferAccounts
-    });
-    const swapResponse = await getSwapIxsForFlashloan({
-      inputMint: borrowOpts.borrowBank.mint.toBase58(),
-      outputMint: depositOpts.depositBank.mint.toBase58(),
-      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
-      swapMode: "ExactIn",
-      authority: marginfiAccount.authority,
-      connection,
-      destinationTokenAccount,
-      swapOpts,
-      sizeConstraint: swapConstraints.sizeConstraint,
-      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
-    });
-    sizeConstraintUsed = swapConstraints.sizeConstraint;
-    const outAmountThreshold = nativeToUi(
-      swapResponse.quoteResponse.otherAmountThreshold,
-      depositOpts.depositBank.mintDecimals
-    );
-    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
-    swapInstructions = swapResponse.swapInstructions;
-    setupInstructions = swapResponse.setupInstructions;
-    swapLookupTables = swapResponse.addressLookupTableAddresses;
-    swapQuote = swapResponse.quoteResponse;
-  }
-  const borrowIxs = await makeBorrowIx3({
-    program,
-    bank: borrowOpts.borrowBank,
-    bankMap,
-    tokenProgram: borrowOpts.tokenProgram,
-    amount: borrowOpts.borrowAmount,
-    marginfiAccount,
-    authority: marginfiAccount.authority,
-    isSync: false,
-    opts: {
-      createAtas: false,
-      wrapAndUnwrapSol: false,
-      overrideInferAccounts
-    }
-  });
-  let depositIxs;
-  switch (depositOpts.depositBank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
-        );
-      }
-      depositIxs = await makeKaminoDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        reserve,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
-        );
-      }
-      const driftMarketIndex = driftState.spotMarketState.marketIndex;
-      const driftOracle = driftState.spotMarketState.oracle;
-      depositIxs = await makeDriftDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex,
-        driftOracle,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    case 6 /* JUPLEND */: {
-      depositIxs = await makeJuplendDepositIx2({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    default: {
-      depositIxs = await makeDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-  }
-  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-  const allNonFlIxs = [
-    ...cuRequestIxs,
-    ...borrowIxs.instructions,
-    ...swapInstructions,
-    ...depositIxs.instructions
-  ];
-  if (swapInstructions.length > 0) {
-    compileFlashloanPrecheck({
-      allIxs: allNonFlIxs,
-      payer: marginfiAccount.authority,
-      luts,
-      sizeConstraint: sizeConstraintUsed,
-      swapIxCount: swapInstructions.length,
-      swapLutCount: swapLookupTables.length
-    });
-  }
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: allNonFlIxs
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
-      txSize,
-      totalKeys,
-      swapOpts.swapConfig?.provider
-    );
-  }
-  return {
-    flashloanTx,
-    setupInstructions,
-    swapQuote,
-    borrowIxs,
-    depositIxs,
-    amountToDeposit
-  };
-}
-
 // src/services/account/actions/emissions.ts
 async function makeClearEmissionsIx(program, marginfiAccount, banks, bankAddress) {
   const bank = banks.get(bankAddress.toBase58());
@@ -48660,7 +48227,7 @@ async function buildSwapCollateralFlashloanTx({
   const txSize = getTxSize(flashloanTx);
   const totalKeys = getTotalAccountKeys(flashloanTx);
   if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
       txSize,
       totalKeys,
       swapOpts.swapConfig?.provider
@@ -48921,7 +48488,7 @@ async function buildSwapDebtFlashloanTx({
   const txSize = getTxSize(flashloanTx);
   const totalKeys = getTotalAccountKeys(flashloanTx);
   if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
       txSize,
       totalKeys,
       swapOpts.swapConfig?.provider
@@ -48935,179 +48502,6 @@ async function buildSwapDebtFlashloanTx({
     repayIxs
   };
 }
-var SYSVAR_CLOCK_ID2 = new PublicKey("SysvarC1ock11111111111111111111111111111111");
-async function makeMintStakedLstIx(params) {
-  const { amount, authority, stakeAccountPk, validator, connection } = params;
-  const pool = findPoolAddress(validator);
-  const lstMint = findPoolMintAddress(pool);
-  const poolStakeAuth = findPoolStakeAuthorityAddress(pool);
-  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
-  const [lstAccInfo, stakeAccInfoParsed, rentExemptReserve] = await Promise.all([
-    connection.getAccountInfo(lstAta),
-    connection.getParsedAccountInfo(stakeAccountPk),
-    connection.getMinimumBalanceForRentExemption(StakeProgram.space)
-  ]);
-  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
-  const amountLamports = Math.round(Number(amount) * LAMPORTS_PER_SOL);
-  const stakeAccLamports = Number(stakeAccParsed?.parsed?.info?.stake?.delegation?.stake ?? 0);
-  const isFullStake = amountLamports >= stakeAccLamports;
-  const instructions2 = [];
-  const signers = [];
-  if (!lstAccInfo) {
-    instructions2.push(
-      createAssociatedTokenAccountInstruction(authority, lstAta, authority, lstMint)
-    );
-  }
-  let targetStakePubkey;
-  if (!isFullStake) {
-    const splitStakeAccount = Keypair.generate();
-    signers.push(splitStakeAccount);
-    targetStakePubkey = splitStakeAccount.publicKey;
-    instructions2.push(
-      ...StakeProgram.split(
-        {
-          stakePubkey: stakeAccountPk,
-          authorizedPubkey: authority,
-          splitStakePubkey: splitStakeAccount.publicKey,
-          lamports: amountLamports
-        },
-        rentExemptReserve
-      ).instructions
-    );
-  } else {
-    targetStakePubkey = stakeAccountPk;
-  }
-  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
-    StakeProgram.authorize({
-      stakePubkey: targetStakePubkey,
-      authorizedPubkey: authority,
-      newAuthorizedPubkey: poolStakeAuth,
-      stakeAuthorizationType: StakeAuthorizationLayout.Staker
-    }).instructions,
-    StakeProgram.authorize({
-      stakePubkey: targetStakePubkey,
-      authorizedPubkey: authority,
-      newAuthorizedPubkey: poolStakeAuth,
-      stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer
-    }).instructions
-  ]);
-  [authorizeStakerIx[0], authorizeWithdrawIx[0]].forEach((ix) => {
-    if (ix) {
-      ix.keys = ix.keys.map((key) => ({
-        ...key,
-        isWritable: key.pubkey.equals(SYSVAR_CLOCK_ID2) ? false : key.isWritable
-      }));
-    }
-  });
-  instructions2.push(...authorizeStakerIx, ...authorizeWithdrawIx);
-  const depositStakeIx = await SinglePoolInstruction.depositStake(
-    pool,
-    targetStakePubkey,
-    lstAta,
-    authority
-  );
-  instructions2.push(depositStakeIx);
-  return { instructions: instructions2, keys: signers };
-}
-async function makeMintStakedLstTx(params) {
-  const { connection, luts, blockhash: providedBlockhash } = params;
-  const { instructions: instructions2, keys } = await makeMintStakedLstIx(params);
-  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const message = new TransactionMessage({
-    payerKey: params.authority,
-    recentBlockhash: blockhash,
-    instructions: instructions2
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    signers: keys,
-    addressLookupTables: luts,
-    type: "DEPOSIT_STAKE" /* DEPOSIT_STAKE */
-  });
-}
-async function makeRedeemStakedLstIx(params) {
-  const { amount, authority, validator, connection } = params;
-  const pool = findPoolAddress(validator);
-  const lstMint = findPoolMintAddress(pool);
-  const mintAuthority = findPoolMintAuthorityAddress(pool);
-  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
-  const rentExemption = await connection.getMinimumBalanceForRentExemption(
-    StakeProgram.space
-  );
-  const stakeAmount = new BigNumber3(new BigNumber3(amount).toString());
-  const instructions2 = [];
-  const signers = [];
-  const stakeAccount = Keypair.generate();
-  signers.push(stakeAccount);
-  instructions2.push(
-    SystemProgram.createAccount({
-      fromPubkey: authority,
-      newAccountPubkey: stakeAccount.publicKey,
-      lamports: rentExemption,
-      space: StakeProgram.space,
-      programId: StakeProgram.programId
-    })
-  );
-  instructions2.push(
-    createApproveInstruction(
-      lstAta,
-      mintAuthority,
-      authority,
-      BigInt(stakeAmount.multipliedBy(1e9).toFixed(0))
-    )
-  );
-  const withdrawStakeIx = await SinglePoolInstruction.withdrawStake(
-    pool,
-    stakeAccount.publicKey,
-    authority,
-    lstAta,
-    stakeAmount
-  );
-  instructions2.push(withdrawStakeIx);
-  return { instructions: instructions2, keys: signers };
-}
-async function makeRedeemStakedLstTx(params) {
-  const { connection, luts, blockhash: providedBlockhash } = params;
-  const { instructions: instructions2, keys } = await makeRedeemStakedLstIx(params);
-  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const message = new TransactionMessage({
-    payerKey: params.authority,
-    recentBlockhash: blockhash,
-    instructions: instructions2
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    signers: keys,
-    addressLookupTables: luts,
-    type: "WITHDRAW_STAKE" /* WITHDRAW_STAKE */
-  });
-}
-async function makeMergeStakeAccountsTx(params) {
-  const {
-    authority,
-    sourceStakeAccount,
-    destinationStakeAccount,
-    connection,
-    luts,
-    blockhash: providedBlockhash
-  } = params;
-  const mergeIx = StakeProgram.merge({
-    stakePubkey: destinationStakeAccount,
-    sourceStakePubKey: sourceStakeAccount,
-    authorizedPubkey: authority
-  }).instructions;
-  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const message = new TransactionMessage({
-    payerKey: authority,
-    recentBlockhash: blockhash,
-    instructions: mergeIx
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    addressLookupTables: luts,
-    type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
-  });
-}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -49956,7 +49350,7 @@ async function getTitanExactOutViaWebSocket(params) {
         inputMint: new PublicKey(inputMint).toBytes(),
         outputMint: new PublicKey(outputMint).toBytes(),
         amount,
-        swapMode: "ExactOut",
+        swapMode: "ExactOut" /* ExactOut */,
         slippageBps
       },
       transaction: {
@@ -50214,140 +49608,575 @@ var getExactOutEstimate = async (params) => {
       );
     }
   }
-  const firstProvider = attempts[0]?.provider ?? "Swap";
-  throw TransactionBuildingError.swapQuoteFailed(
-    firstProvider,
-    inputMint,
-    outputMint,
-    lastError?.message ?? "No swap route available"
-  );
-};
-function mapJupiterQuoteToSwapQuoteResult(quote) {
-  return {
-    inAmount: quote.inAmount,
-    outAmount: quote.outAmount,
-    otherAmountThreshold: quote.otherAmountThreshold,
-    slippageBps: quote.slippageBps,
-    platformFee: quote.platformFee ? {
-      amount: quote.platformFee.amount ?? "0",
-      feeBps: quote.platformFee.feeBps ?? 0
-    } : void 0,
-    priceImpactPct: quote.priceImpactPct,
-    contextSlot: quote.contextSlot,
-    timeTaken: quote.timeTaken,
-    provider: "JUPITER" /* JUPITER */
-  };
-}
-
-// src/services/account/utils/jupiter.utils.ts
-var REFERRAL_PROGRAM_ID = new PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
-var REFERRAL_ACCOUNT_PUBKEY = new PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
-var getFeeAccount = (mint) => {
-  const [feeAccount] = PublicKey.findProgramAddressSync(
-    [Buffer.from("referral_ata"), REFERRAL_ACCOUNT_PUBKEY.toBuffer(), mint.toBuffer()],
-    REFERRAL_PROGRAM_ID
-  );
-  return feeAccount.toBase58();
-};
-var checkFeeAccount = async (connection, mint) => {
-  const feeAccount = getFeeAccount(mint);
-  const hasFeeAccount = !!await connection.getAccountInfo(new PublicKey(feeAccount));
-  return { feeAccount, hasFeeAccount };
-};
-function deserializeJupiterInstruction(instruction) {
-  return new TransactionInstruction({
-    programId: new PublicKey(instruction.programId),
-    keys: instruction.accounts.map((key) => ({
-      pubkey: new PublicKey(key.pubkey),
-      isSigner: key.isSigner,
-      isWritable: key.isWritable
-    })),
-    data: Buffer.from(instruction.data, "base64")
-  });
-}
-function toJupiterConfig(apiConfig) {
-  if (!apiConfig) return void 0;
-  return {
-    basePath: apiConfig.basePath,
-    apiKey: apiConfig.apiKey ? () => apiConfig.apiKey : void 0,
-    headers: apiConfig.headers
-  };
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+function mapJupiterQuoteToSwapQuoteResult(quote) {
+  return {
+    inAmount: quote.inAmount,
+    outAmount: quote.outAmount,
+    otherAmountThreshold: quote.otherAmountThreshold,
+    slippageBps: quote.slippageBps,
+    platformFee: quote.platformFee ? {
+      amount: quote.platformFee.amount ?? "0",
+      feeBps: quote.platformFee.feeBps ?? 0
+    } : void 0,
+    priceImpactPct: quote.priceImpactPct,
+    contextSlot: quote.contextSlot,
+    timeTaken: quote.timeTaken,
+    provider: "JUPITER" /* JUPITER */
+  };
+}
+
+// src/services/account/utils/jupiter.utils.ts
+var REFERRAL_PROGRAM_ID = new PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
+var REFERRAL_ACCOUNT_PUBKEY = new PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
+var getFeeAccount = (mint) => {
+  const [feeAccount] = PublicKey.findProgramAddressSync(
+    [Buffer.from("referral_ata"), REFERRAL_ACCOUNT_PUBKEY.toBuffer(), mint.toBuffer()],
+    REFERRAL_PROGRAM_ID
+  );
+  return feeAccount.toBase58();
+};
+var checkFeeAccount = async (connection, mint) => {
+  const feeAccount = getFeeAccount(mint);
+  const hasFeeAccount = !!await connection.getAccountInfo(new PublicKey(feeAccount));
+  return { feeAccount, hasFeeAccount };
+};
+function deserializeJupiterInstruction(instruction) {
+  return new TransactionInstruction({
+    programId: new PublicKey(instruction.programId),
+    keys: instruction.accounts.map((key) => ({
+      pubkey: new PublicKey(key.pubkey),
+      isSigner: key.isSigner,
+      isWritable: key.isWritable
+    })),
+    data: Buffer.from(instruction.data, "base64")
+  });
+}
+function toJupiterConfig(apiConfig) {
+  if (!apiConfig) return void 0;
+  return {
+    basePath: apiConfig.basePath,
+    apiKey: apiConfig.apiKey ? () => apiConfig.apiKey : void 0,
+    headers: apiConfig.headers
+  };
+}
+var getJupiterSwapIxsForFlashloan = async ({
+  quoteParams,
+  authority,
+  connection,
+  destinationTokenAccount,
+  apiConfig,
+  maxSwapAccounts
+}) => {
+  const configParams = toJupiterConfig(apiConfig);
+  const jupiterApiClient = configParams?.basePath ? new SwapApi(new Configuration(configParams)) : createJupiterApiClient(configParams);
+  const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
+  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new PublicKey(feeMint));
+  const project0JupiterLut = (await connection.getAddressLookupTable(ADDRESS_LOOKUP_TABLE_FOR_SWAP))?.value;
+  let finalQuoteParams = quoteParams;
+  if (!hasFeeAccount) {
+    console.warn("Warning: feeAccountInfo is undefined");
+    finalQuoteParams = {
+      ...quoteParams,
+      platformFeeBps: void 0
+    };
+  }
+  const JUPITER_MAX_ACCOUNTS_MARGIN = 4;
+  const maxAccounts = maxSwapAccounts !== void 0 ? maxSwapAccounts - JUPITER_MAX_ACCOUNTS_MARGIN : 40;
+  const swapQuote = await jupiterApiClient.quoteGet({
+    ...finalQuoteParams,
+    maxAccounts
+  });
+  const swapInstructionResponse = await jupiterApiClient.swapInstructionsPost({
+    swapRequest: {
+      quoteResponse: swapQuote,
+      userPublicKey: authority.toBase58(),
+      feeAccount: hasFeeAccount ? feeAccount : void 0,
+      wrapAndUnwrapSol: false,
+      destinationTokenAccount: destinationTokenAccount.toBase58()
+    }
+  });
+  const lutAddresses = swapInstructionResponse.addressLookupTableAddresses;
+  const lutAccountsRaw = await connection.getMultipleAccountsInfo(
+    lutAddresses.map((address) => new PublicKey(address))
+  );
+  const addressLookupTableAccounts = lutAccountsRaw.map((accountInfo, index) => {
+    const addressLookupTableAddress = lutAddresses[index];
+    if (!accountInfo || !addressLookupTableAddress) {
+      return null;
+    }
+    return new AddressLookupTableAccount({
+      key: new PublicKey(addressLookupTableAddress),
+      state: AddressLookupTableAccount.deserialize(accountInfo.data)
+    });
+  }).filter((account) => account !== null).concat(project0JupiterLut ? [project0JupiterLut] : []);
+  const instruction = deserializeJupiterInstruction(swapInstructionResponse.swapInstruction);
+  const setupInstructions = swapInstructionResponse.setupInstructions.map(
+    deserializeJupiterInstruction
+  );
+  return {
+    swapInstructions: [instruction],
+    setupInstructions,
+    addressLookupTableAddresses: addressLookupTableAccounts,
+    quoteResponse: mapJupiterQuoteToSwapQuoteResult(swapQuote)
+  };
+};
+
+// src/services/account/utils/misc.utils.ts
+function floor(value, decimals) {
+  return Math.floor(value * 10 ** decimals) / 10 ** decimals;
+}
+function ceil(value, decimals) {
+  return Math.ceil(value * 10 ** decimals) / 10 ** decimals;
+}
+function computeClosePositionTokenAmount(position, mintDecimals) {
+  const closePositionTokenAmount = position.isLending ? floor(position.amount, mintDecimals) : ceil(position.amount, mintDecimals);
+  return closePositionTokenAmount;
+}
+function isWholePosition(position, amount, mintDecimals) {
+  const closePositionTokenAmount = computeClosePositionTokenAmount(position, mintDecimals);
+  return amount >= closePositionTokenAmount;
+}
+var SWAP_MERGE_OVERHEAD = 150;
+var FL_IX_OVERHEAD = 52;
+function compactU16Size(n) {
+  return n < 128 ? 1 : n < 16384 ? 2 : 3;
+}
+function computeV0TxSize(ixs, payerKey, luts) {
+  const keyMap = /* @__PURE__ */ new Map();
+  const payerStr = payerKey.toBase58();
+  keyMap.set(payerStr, { isSigner: true, isWritable: true });
+  const programIds = /* @__PURE__ */ new Set();
+  for (const ix of ixs) {
+    const progStr = ix.programId.toBase58();
+    programIds.add(progStr);
+    if (!keyMap.has(progStr)) {
+      keyMap.set(progStr, { isSigner: false, isWritable: false });
+    }
+    for (const meta of ix.keys) {
+      const keyStr = meta.pubkey.toBase58();
+      const existing = keyMap.get(keyStr);
+      if (existing) {
+        existing.isSigner = existing.isSigner || meta.isSigner;
+        existing.isWritable = existing.isWritable || meta.isWritable;
+      } else {
+        keyMap.set(keyStr, { isSigner: meta.isSigner, isWritable: meta.isWritable });
+      }
+    }
+  }
+  const lutLookup = /* @__PURE__ */ new Map();
+  for (let li = 0; li < luts.length; li++) {
+    const addresses = luts[li].state.addresses;
+    for (let ai = 0; ai < addresses.length; ai++) {
+      const addrStr = addresses[ai].toBase58();
+      if (!lutLookup.has(addrStr)) {
+        lutLookup.set(addrStr, { lutIdx: li, addrIdx: ai });
+      }
+    }
+  }
+  let numStaticKeys = 0;
+  let numWritableStaticKeys = 0;
+  const lutWritableIdxs = luts.map(() => /* @__PURE__ */ new Set());
+  const lutReadonlyIdxs = luts.map(() => /* @__PURE__ */ new Set());
+  for (const [keyStr, props] of keyMap) {
+    if (props.isSigner || programIds.has(keyStr)) {
+      numStaticKeys++;
+      if (props.isWritable) numWritableStaticKeys++;
+      continue;
+    }
+    const lutEntry = lutLookup.get(keyStr);
+    if (lutEntry) {
+      if (props.isWritable) {
+        lutWritableIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
+      } else {
+        lutReadonlyIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
+      }
+    } else {
+      numStaticKeys++;
+      if (props.isWritable) numWritableStaticKeys++;
+    }
+  }
+  const fixedOverhead = 101;
+  const staticKeysSection = compactU16Size(numStaticKeys) + numStaticKeys * 32;
+  let ixSection = compactU16Size(ixs.length);
+  for (const ix of ixs) {
+    const numAccounts = ix.keys.length;
+    ixSection += 1 + // programId index
+    compactU16Size(numAccounts) + numAccounts + // account key indexes
+    compactU16Size(ix.data.length) + ix.data.length;
+  }
+  let numUsedLuts = 0;
+  let lutSection = 0;
+  for (let li = 0; li < luts.length; li++) {
+    const wCount = lutWritableIdxs[li].size;
+    const rCount = lutReadonlyIdxs[li].size;
+    if (wCount === 0 && rCount === 0) continue;
+    numUsedLuts++;
+    lutSection += 32 + // LUT address
+    compactU16Size(wCount) + wCount + // writable indexes
+    compactU16Size(rCount) + rCount;
+  }
+  lutSection += compactU16Size(numUsedLuts);
+  let totalLutKeys = 0;
+  for (let li = 0; li < luts.length; li++) {
+    totalLutKeys += lutWritableIdxs[li].size + lutReadonlyIdxs[li].size;
+  }
+  const accountCount = numStaticKeys + totalLutKeys;
+  let totalLutWritableKeys = 0;
+  for (let li = 0; li < luts.length; li++) {
+    totalLutWritableKeys += lutWritableIdxs[li].size;
+  }
+  const writableAccountCount = numWritableStaticKeys + totalLutWritableKeys;
+  const size = fixedOverhead + staticKeysSection + ixSection + lutSection + 1;
+  return { size, accountCount, writableAccountCount };
+}
+function computeFlashLoanNonSwapBudget({
+  program,
+  marginfiAccount,
+  ixs,
+  bankMap,
+  addressLookupTableAccounts
+}) {
+  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
+    marginfiAccount.balances,
+    ixs,
+    program
+  );
+  const projectedActiveBanks = projectedActiveBanksKeys.map((key) => {
+    const b = bankMap.get(key.toBase58());
+    if (!b) throw new Error(`Bank ${key.toBase58()} not found in computeFlashLoanNonSwapBudget`);
+    return b;
+  });
+  const endIndex = ixs.length + 1;
+  const beginFlIx = sync_instructions_default.makeBeginFlashLoanIx(
+    program.programId,
+    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
+    { endIndex: new BN11(endIndex) }
+  );
+  const endFlRemainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const endFlIx = sync_instructions_default.makeEndFlashLoanIx(
+    program.programId,
+    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
+    endFlRemainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false }))
+  );
+  const allNonSwapIxs = [beginFlIx, ...ixs, endFlIx];
+  const nonSwapMsg = new TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: PublicKey.default.toBase58(),
+    instructions: allNonSwapIxs
+  }).compileToV0Message(addressLookupTableAccounts);
+  const nonSwapSize = new VersionedTransaction(nonSwapMsg).serialize().length;
+  const { header, staticAccountKeys, addressTableLookups } = nonSwapMsg;
+  const nonSwapTotal = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  const sizeConstraint = MAX_TX_SIZE - nonSwapSize - SWAP_MERGE_OVERHEAD;
+  const maxSwapTotalAccounts = MAX_ACCOUNT_LOCKS - nonSwapTotal;
+  console.log("[flashloan-budget]", {
+    method: "compiled",
+    nonSwapSize,
+    nonSwapTotal,
+    sizeConstraint,
+    maxSwapTotalAccounts
+  });
+  return { sizeConstraint, maxSwapTotalAccounts };
+}
+function compileFlashloanPrecheck({
+  allIxs,
+  payer,
+  luts,
+  sizeConstraint,
+  swapIxCount,
+  swapLutCount
+}) {
+  const msg = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: PublicKey.default.toBase58(),
+    instructions: allIxs
+  }).compileToV0Message(luts);
+  const rawSize = new VersionedTransaction(msg).serialize().length;
+  const fullTxSize = rawSize + FL_IX_OVERHEAD;
+  const overshoot = fullTxSize - MAX_TX_SIZE;
+  const { header, staticAccountKeys, addressTableLookups } = msg;
+  const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
+  const writableLut = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+  const writableAccounts = writableStatic + writableLut;
+  const totalAccounts = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  console.log("[flashloan-precheck]", {
+    fullTxSize,
+    overshoot,
+    sizeConstraint,
+    writableAccounts,
+    totalAccounts,
+    staticKeys: staticAccountKeys.length,
+    numLuts: addressTableLookups.length,
+    swapIxCount,
+    swapLutCount
+  });
+  return { fullTxSize, overshoot, writableAccounts, totalAccounts };
+}
+async function buildBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  switch (config.type) {
+    case "borrow":
+      return makeBorrowIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        isSync: true,
+        opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "repay":
+      return makeRepayIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        repayAll: false,
+        isSync: true,
+        opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "deposit":
+      return buildDepositBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
+    case "withdraw":
+      return buildWithdrawBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMap,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
+  }
+}
+async function buildDepositBudgetIx(config, program, marginfiAccount, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  const opts = { wrapAndUnwrapSol: false, overrideInferAccounts };
+  switch (bank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeKaminoDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        isSync: true,
+        opts
+      });
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeDriftDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        driftMarketIndex: driftState.spotMarketState.marketIndex,
+        driftOracle: driftState.spotMarketState.oracle,
+        isSync: true,
+        opts
+      });
+    }
+    case 6 /* JUPLEND */: {
+      return makeJuplendDepositIx2({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        isSync: true,
+        opts
+      });
+    }
+    default: {
+      return makeDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        isSync: true,
+        opts
+      });
+    }
+  }
 }
-var getJupiterSwapIxsForFlashloan = async ({
-  quoteParams,
-  authority,
-  connection,
-  destinationTokenAccount,
-  apiConfig,
-  maxSwapAccounts
-}) => {
-  const configParams = toJupiterConfig(apiConfig);
-  const jupiterApiClient = configParams?.basePath ? new SwapApi(new Configuration(configParams)) : createJupiterApiClient(configParams);
-  const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
-  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new PublicKey(feeMint));
-  const project0JupiterLut = (await connection.getAddressLookupTable(ADDRESS_LOOKUP_TABLE_FOR_SWAP))?.value;
-  let finalQuoteParams = quoteParams;
-  if (!hasFeeAccount) {
-    console.warn("Warning: feeAccountInfo is undefined");
-    finalQuoteParams = {
-      ...quoteParams,
-      platformFeeBps: void 0
-    };
-  }
-  const maxAccounts = maxSwapAccounts ?? 40;
-  const swapQuote = await jupiterApiClient.quoteGet({
-    ...finalQuoteParams,
-    maxAccounts
-  });
-  const swapInstructionResponse = await jupiterApiClient.swapInstructionsPost({
-    swapRequest: {
-      quoteResponse: swapQuote,
-      userPublicKey: authority.toBase58(),
-      feeAccount: hasFeeAccount ? feeAccount : void 0,
-      wrapAndUnwrapSol: false,
-      destinationTokenAccount: destinationTokenAccount.toBase58()
+async function buildWithdrawBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  const opts = { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts };
+  switch (bank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeKaminoWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        cTokenAmount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        reserve,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
     }
-  });
-  const lutAddresses = swapInstructionResponse.addressLookupTableAddresses;
-  const lutAccountsRaw = await connection.getMultipleAccountsInfo(
-    lutAddresses.map((address) => new PublicKey(address))
-  );
-  const addressLookupTableAccounts = lutAccountsRaw.map((accountInfo, index) => {
-    const addressLookupTableAddress = lutAddresses[index];
-    if (!accountInfo || !addressLookupTableAddress) {
-      return null;
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeDriftWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
     }
-    return new AddressLookupTableAccount({
-      key: new PublicKey(addressLookupTableAddress),
-      state: AddressLookupTableAccount.deserialize(accountInfo.data)
-    });
-  }).filter((account) => account !== null).concat(project0JupiterLut ? [project0JupiterLut] : []);
-  const instruction = deserializeJupiterInstruction(swapInstructionResponse.swapInstruction);
-  const setupInstructions = swapInstructionResponse.setupInstructions.map(
-    deserializeJupiterInstruction
-  );
-  return {
-    swapInstructions: [instruction],
-    setupInstructions,
-    addressLookupTableAddresses: addressLookupTableAccounts,
-    quoteResponse: mapJupiterQuoteToSwapQuoteResult(swapQuote)
-  };
-};
-
-// src/services/account/utils/misc.utils.ts
-function floor(value, decimals) {
-  return Math.floor(value * 10 ** decimals) / 10 ** decimals;
-}
-function ceil(value, decimals) {
-  return Math.ceil(value * 10 ** decimals) / 10 ** decimals;
-}
-function computeClosePositionTokenAmount(position, mintDecimals) {
-  const closePositionTokenAmount = position.isLending ? floor(position.amount, mintDecimals) : ceil(position.amount, mintDecimals);
-  return closePositionTokenAmount;
+    case 6 /* JUPLEND */: {
+      const jupLendState = bankMetadataMap[bank.address.toBase58()]?.jupLendStates;
+      if (!jupLendState) {
+        throw TransactionBuildingError.jupLendStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeJuplendWithdrawIx2({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        jupLendingState: jupLendState.jupLendingState,
+        withdrawAll: false,
+        opts
+      });
+    }
+    default: {
+      return makeWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
+    }
+  }
 }
-function isWholePosition(position, amount, mintDecimals) {
-  const closePositionTokenAmount = computeClosePositionTokenAmount(position, mintDecimals);
-  return amount >= closePositionTokenAmount;
+async function computeFlashloanSwapConstraints({
+  program,
+  marginfiAccount,
+  bankMap,
+  addressLookupTableAccounts,
+  bankMetadataMap,
+  primaryIx,
+  secondaryIx,
+  overrideInferAccounts
+}) {
+  const cuRequestIxs = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const [primaryResult, secondaryResult] = await Promise.all([
+    buildBudgetIx(
+      primaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    ),
+    buildBudgetIx(
+      secondaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    )
+  ]);
+  return computeFlashLoanNonSwapBudget({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts,
+    ixs: [...cuRequestIxs, ...primaryResult.instructions, ...secondaryResult.instructions]
+  });
 }
 
 // src/services/price/utils/smart-crank.utils.ts
@@ -51827,6 +51656,78 @@ function computeRemainingCapacity(bank) {
   };
 }
 
+// src/services/bank/utils/bank-metrics.utils.ts
+function computeBankTotalDeposits(bank, assetShareValueMultiplier) {
+  const totalAssets = getTotalAssetQuantity(bank).times(
+    assetShareValueMultiplier ?? 1
+  );
+  return nativeToUi(totalAssets, bank.mintDecimals);
+}
+function computeBankTotalBorrows(bank) {
+  return nativeToUi(getTotalLiabilityQuantity(bank), bank.mintDecimals);
+}
+function computeBankTotalDepositsUsd(bank, oraclePrice, assetShareValueMultiplier) {
+  return computeUsdValue({
+    bank,
+    oraclePrice,
+    quantity: getTotalAssetQuantity(bank),
+    priceBias: 1 /* None */,
+    isWeightedPrice: false,
+    assetShareValueMultiplier
+  }).toNumber();
+}
+function computeBankTotalBorrowsUsd(bank, oraclePrice) {
+  return computeUsdValue({
+    bank,
+    oraclePrice,
+    quantity: getTotalLiabilityQuantity(bank),
+    priceBias: 1 /* None */,
+    isWeightedPrice: false
+  }).toNumber();
+}
+function computeBankPoolSize(bank, assetShareValueMultiplier) {
+  const totalDeposits = computeBankTotalDeposits(bank, assetShareValueMultiplier);
+  const totalBorrows = computeBankTotalBorrows(bank);
+  const borrowCap = nativeToUi(bank.config.borrowLimit, bank.mintDecimals);
+  return Math.max(0, Math.min(totalDeposits, borrowCap) - totalBorrows);
+}
+function computeBankDepositCapRemaining(bank) {
+  const { depositCapacity } = computeRemainingCapacity(bank);
+  return Math.max(0, nativeToUi(depositCapacity, bank.mintDecimals));
+}
+function computeBankBorrowCapRemaining(bank) {
+  const { borrowCapacity } = computeRemainingCapacity(bank);
+  return Math.max(0, nativeToUi(borrowCapacity, bank.mintDecimals));
+}
+function computeBankSupplyApy(bank) {
+  return aprToApy(computeInterestRates(bank).lendingRate.toNumber());
+}
+function computeBankBorrowApy(bank) {
+  return aprToApy(computeInterestRates(bank).borrowingRate.toNumber());
+}
+function computeBankMetrics(params) {
+  const { bank, oraclePrice, assetShareValueMultiplier, symbol = "" } = params;
+  return {
+    symbol,
+    totalDeposits: computeBankTotalDeposits(bank, assetShareValueMultiplier),
+    totalBorrows: computeBankTotalBorrows(bank),
+    totalDepositsUsd: computeBankTotalDepositsUsd(
+      bank,
+      oraclePrice,
+      assetShareValueMultiplier
+    ),
+    totalBorrowsUsd: computeBankTotalBorrowsUsd(bank, oraclePrice),
+    utilizationRate: computeUtilizationRate(bank).toNumber(),
+    poolSize: computeBankPoolSize(bank, assetShareValueMultiplier),
+    depositCap: nativeToUi(bank.config.depositLimit, bank.mintDecimals),
+    borrowCap: nativeToUi(bank.config.borrowLimit, bank.mintDecimals),
+    depositCapRemaining: computeBankDepositCapRemaining(bank),
+    borrowCapRemaining: computeBankBorrowCapRemaining(bank),
+    supplyApy: computeBankSupplyApy(bank),
+    borrowApy: computeBankBorrowApy(bank)
+  };
+}
+
 // src/services/bank/bank.service.ts
 async function freezeBankConfigIx(program, bankAddress, bankConfigOpt) {
   let bankConfigRaw;
@@ -52611,6 +52512,230 @@ function getValidatorVoteAccountByBank() {
   }
   return _voteAccountByBank;
 }
+async function computeStakedBankMultipliers(stakedBanks, connection) {
+  const multiplierByBank = /* @__PURE__ */ new Map();
+  if (stakedBanks.length === 0) {
+    return multiplierByBank;
+  }
+  const metadataMap = getStakedBankMetadataMap();
+  const stakedBankAddresses = [];
+  const poolStakeAddresses = [];
+  const lstMintAddresses = [];
+  for (const bank of stakedBanks) {
+    const metadata = metadataMap.get(bank.address.toBase58());
+    if (!metadata) {
+      multiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
+      continue;
+    }
+    const pool = findPoolAddress(new PublicKey(metadata.validatorVoteAccount));
+    stakedBankAddresses.push(bank.address.toBase58());
+    poolStakeAddresses.push(findPoolStakeAddress(pool));
+    lstMintAddresses.push(findPoolMintAddress(pool));
+  }
+  if (stakedBankAddresses.length === 0) {
+    return multiplierByBank;
+  }
+  const allAddresses = [
+    ...poolStakeAddresses.map((a) => a.toBase58()),
+    ...lstMintAddresses.map((a) => a.toBase58())
+  ];
+  const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(connection, allAddresses);
+  const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
+  const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
+  for (let i = 0; i < stakedBankAddresses.length; i++) {
+    const bankAddr = stakedBankAddresses[i];
+    const poolStakeInfo = poolStakeInfos[i];
+    const lstMintInfo = lstMintInfos[i];
+    if (!poolStakeInfo || !lstMintInfo) {
+      multiplierByBank.set(bankAddr, new BigNumber3(1));
+      continue;
+    }
+    const stakeLamports = poolStakeInfo.lamports;
+    const supplyBuffer = lstMintInfo.data.slice(36, 44);
+    const lstMintSupply = Number(Buffer.from(supplyBuffer).readBigUInt64LE(0));
+    if (lstMintSupply === 0) {
+      multiplierByBank.set(bankAddr, new BigNumber3(1));
+      continue;
+    }
+    const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL, 0);
+    const multiplier = new BigNumber3(adjustedStake).dividedBy(lstMintSupply);
+    multiplierByBank.set(bankAddr, multiplier);
+  }
+  return multiplierByBank;
+}
+var SYSVAR_CLOCK_ID2 = new PublicKey("SysvarC1ock11111111111111111111111111111111");
+async function makeMintStakedLstIx(params) {
+  const { amount, authority, stakeAccountPk, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const poolStakeAuth = findPoolStakeAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const [lstAccInfo, stakeAccInfoParsed, rentExemptReserve] = await Promise.all([
+    connection.getAccountInfo(lstAta),
+    connection.getParsedAccountInfo(stakeAccountPk),
+    connection.getMinimumBalanceForRentExemption(StakeProgram.space)
+  ]);
+  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
+  const amountLamports = Math.round(Number(amount) * LAMPORTS_PER_SOL);
+  const stakeAccLamports = Number(stakeAccParsed?.parsed?.info?.stake?.delegation?.stake ?? 0);
+  const isFullStake = amountLamports >= stakeAccLamports;
+  const instructions2 = [];
+  const signers = [];
+  if (!lstAccInfo) {
+    instructions2.push(
+      createAssociatedTokenAccountInstruction(authority, lstAta, authority, lstMint)
+    );
+  }
+  let targetStakePubkey;
+  if (!isFullStake) {
+    const splitStakeAccount = Keypair.generate();
+    signers.push(splitStakeAccount);
+    targetStakePubkey = splitStakeAccount.publicKey;
+    instructions2.push(
+      ...StakeProgram.split(
+        {
+          stakePubkey: stakeAccountPk,
+          authorizedPubkey: authority,
+          splitStakePubkey: splitStakeAccount.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      ).instructions
+    );
+  } else {
+    targetStakePubkey = stakeAccountPk;
+  }
+  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
+    StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: StakeAuthorizationLayout.Staker
+    }).instructions,
+    StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer
+    }).instructions
+  ]);
+  [authorizeStakerIx[0], authorizeWithdrawIx[0]].forEach((ix) => {
+    if (ix) {
+      ix.keys = ix.keys.map((key) => ({
+        ...key,
+        isWritable: key.pubkey.equals(SYSVAR_CLOCK_ID2) ? false : key.isWritable
+      }));
+    }
+  });
+  instructions2.push(...authorizeStakerIx, ...authorizeWithdrawIx);
+  const depositStakeIx = await SinglePoolInstruction.depositStake(
+    pool,
+    targetStakePubkey,
+    lstAta,
+    authority
+  );
+  instructions2.push(depositStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeMintStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeMintStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "DEPOSIT_STAKE" /* DEPOSIT_STAKE */
+  });
+}
+async function makeRedeemStakedLstIx(params) {
+  const { amount, authority, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const mintAuthority = findPoolMintAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const rentExemption = await connection.getMinimumBalanceForRentExemption(
+    StakeProgram.space
+  );
+  const stakeAmount = new BigNumber3(new BigNumber3(amount).toString());
+  const instructions2 = [];
+  const signers = [];
+  const stakeAccount = Keypair.generate();
+  signers.push(stakeAccount);
+  instructions2.push(
+    SystemProgram.createAccount({
+      fromPubkey: authority,
+      newAccountPubkey: stakeAccount.publicKey,
+      lamports: rentExemption,
+      space: StakeProgram.space,
+      programId: StakeProgram.programId
+    })
+  );
+  instructions2.push(
+    createApproveInstruction(
+      lstAta,
+      mintAuthority,
+      authority,
+      BigInt(stakeAmount.multipliedBy(1e9).toFixed(0))
+    )
+  );
+  const withdrawStakeIx = await SinglePoolInstruction.withdrawStake(
+    pool,
+    stakeAccount.publicKey,
+    authority,
+    lstAta,
+    stakeAmount
+  );
+  instructions2.push(withdrawStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeRedeemStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeRedeemStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "WITHDRAW_STAKE" /* WITHDRAW_STAKE */
+  });
+}
+async function makeMergeStakeAccountsTx(params) {
+  const {
+    authority,
+    sourceStakeAccount,
+    destinationStakeAccount,
+    connection,
+    luts,
+    blockhash: providedBlockhash
+  } = params;
+  const mergeIx = StakeProgram.merge({
+    stakePubkey: destinationStakeAccount,
+    sourceStakePubKey: sourceStakeAccount,
+    authorizedPubkey: authority
+  }).instructions;
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: authority,
+    recentBlockhash: blockhash,
+    instructions: mergeIx
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    addressLookupTables: luts,
+    type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
+  });
+}
 async function getKaminoMetadata(options) {
   const kaminoBanks = options.banks.filter((b) => b.config.assetTag === 3 /* KAMINO */);
   const DEFAULT_PUBKEY = PublicKey.default;
@@ -55047,66 +55172,6 @@ var MarginfiAccountWrapper = class {
     return this.account.getHealthCheckAccounts(this.client.bankMap, mandatoryBanks, excludedBanks);
   }
   // ----------------------------------------------------------------------------
-  // Native stake actions
-  // Note: These call standalone action functions directly rather than routing
-  // through this.account because they interact with the SPL stake pool program,
-  // not the marginfi program. No MarginfiAccount state is needed.
-  // ----------------------------------------------------------------------------
-  /**
-   * Creates a transaction to mint LST from a native stake account.
-   *
-   * Converts a native stake account (or a portion of it) into LST tokens
-   * by depositing the stake into the single-validator pool.
-   *
-   * @param amount - SOL amount to convert (in UI units)
-   * @param stakeAccountPk - The stake account to convert
-   * @param validator - The validator vote account
-   */
-  async makeMintStakedLstTx(amount, stakeAccountPk, validator) {
-    return makeMintStakedLstTx({
-      amount,
-      authority: this.authority,
-      stakeAccountPk,
-      validator,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  /**
-   * Creates a transaction to redeem LST tokens back to a native stake account.
-   *
-   * Burns LST tokens and withdraws the underlying stake into a new stake account.
-   *
-   * @param amount - LST amount to redeem (in UI units)
-   * @param validator - The validator vote account
-   */
-  async makeRedeemStakedLstTx(amount, validator) {
-    return makeRedeemStakedLstTx({
-      amount,
-      authority: this.authority,
-      validator,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  /**
-   * Creates a transaction to merge two stake accounts.
-   *
-   * Both accounts must share the same authorized staker/withdrawer and vote account.
-   *
-   * @param sourceStakeAccount - The stake account to merge from (will be consumed)
-   * @param destinationStakeAccount - The stake account to merge into
-   */
-  async makeMergeStakeAccountsTx(sourceStakeAccount, destinationStakeAccount) {
-    return makeMergeStakeAccountsTx({
-      authority: this.authority,
-      sourceStakeAccount,
-      destinationStakeAccount,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  // ----------------------------------------------------------------------------
   // Helper methods
   // ----------------------------------------------------------------------------
   /**
@@ -55376,56 +55441,11 @@ var Project0Client = class _Project0Client {
           break;
       }
     });
-    const stakedBanks = banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */);
-    if (stakedBanks.length > 0) {
-      const metadataMap = getStakedBankMetadataMap();
-      const stakedBankAddresses = [];
-      const poolStakeAddresses = [];
-      const lstMintAddresses = [];
-      for (const bank of stakedBanks) {
-        const metadata = metadataMap.get(bank.address.toBase58());
-        if (!metadata) {
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
-          continue;
-        }
-        const pool = findPoolAddress(new PublicKey(metadata.validatorVoteAccount));
-        stakedBankAddresses.push(bank.address.toBase58());
-        poolStakeAddresses.push(findPoolStakeAddress(pool));
-        lstMintAddresses.push(findPoolMintAddress(pool));
-      }
-      if (stakedBankAddresses.length > 0) {
-        const allAddresses = [
-          ...poolStakeAddresses.map((a) => a.toBase58()),
-          ...lstMintAddresses.map((a) => a.toBase58())
-        ];
-        const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(
-          connection,
-          allAddresses
-        );
-        const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
-        const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
-        for (let i = 0; i < stakedBankAddresses.length; i++) {
-          const bankAddr = stakedBankAddresses[i];
-          const poolStakeInfo = poolStakeInfos[i];
-          const lstMintInfo = lstMintInfos[i];
-          if (!poolStakeInfo || !lstMintInfo) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3(1));
-            continue;
-          }
-          const stakeLamports = poolStakeInfo.lamports;
-          const supplyBuffer = lstMintInfo.data.slice(36, 44);
-          const lstMintSupply = Number(Buffer.from(supplyBuffer).readBigUInt64LE(0));
-          if (lstMintSupply === 0) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3(1));
-            continue;
-          }
-          const LAMPORTS_PER_SOL5 = 1e9;
-          const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL5, 0);
-          const multiplier = new BigNumber3(adjustedStake).dividedBy(lstMintSupply);
-          assetShareMultiplierByBank.set(bankAddr, multiplier);
-        }
-      }
-    }
+    const stakedMultipliers = await computeStakedBankMultipliers(
+      banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */),
+      connection
+    );
+    stakedMultipliers.forEach((v, k) => assetShareMultiplierByBank.set(k, v));
     const emodePairs = getEmodePairs(banksArray);
     return new _Project0Client(
       program,
@@ -55467,6 +55487,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_ORACLE_MAX_AGE, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkMultipleOraclesCrankability, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, compileFlashloanPrecheck, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeHealthComponentsWithoutBiasFromBalances, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountAddresses, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isFlashloan, isV0Tx, isWeightedPrice, isWholePosition, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeClearEmissionsIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, resolveAmount, serializeBankConfigOpt, serializeInterestRateConfig, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, toBankConfigDto, toBankDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
+export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_ORACLE_MAX_AGE, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkMultipleOraclesCrankability, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, compileFlashloanPrecheck, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeHealthComponentsWithoutBiasFromBalances, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountAddresses, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isFlashloan, isV0Tx, isWeightedPrice, isWholePosition, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeClearEmissionsIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, resolveAmount, serializeBankConfigOpt, serializeInterestRateConfig, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, toBankConfigDto, toBankDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map