@0dotxyz/p0-ts-sdk 2.2.0-beta.3 → 2.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
-import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, Transaction, AddressLookupTableAccount, SYSVAR_RENT_PUBKEY, StakeProgram, TransactionInstruction, LAMPORTS_PER_SOL, SYSVAR_INSTRUCTIONS_PUBKEY } 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 from 'bn.js';
+import BN11, { BN } from 'bn.js';
 import Decimal3, { Decimal } from 'decimal.js';
 import { BorshCoder, BorshAccountsCoder, BorshInstructionCoder, AnchorProvider, Program } from '@coral-xyz/anchor';
 import { struct, u32, u8 } from '@solana/buffer-layout';
@@ -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
    */
@@ -15136,9 +15125,48 @@ var MintLayout = struct([
   publicKey("freezeAuthority")
 ]);
 MintLayout.span;
+var approveInstructionData = struct([
+  u8("instruction"),
+  u64("amount")
+]);
+function createApproveInstruction(account, delegate, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
+  const keys = addSigners(
+    [
+      { pubkey: account, isSigner: false, isWritable: true },
+      { pubkey: delegate, isSigner: false, isWritable: false }
+    ],
+    owner,
+    multiSigners
+  );
+  const data = Buffer$1.alloc(approveInstructionData.span);
+  approveInstructionData.encode(
+    {
+      instruction: 4 /* Approve */,
+      amount: BigInt(amount)
+    },
+    data
+  );
+  return new TransactionInstruction({ keys, programId, data });
+}
 struct([
   u8("instruction")
 ]);
+function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+  const keys = [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: associatedToken, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+  ];
+  return new TransactionInstruction({
+    keys,
+    programId: associatedTokenProgramId,
+    data: Buffer$1.alloc(0)
+  });
+}
 function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
   return buildAssociatedTokenAccountInstruction(
     payer,
@@ -43351,6 +43379,173 @@ new Fraction(new BN11(0));
 function roundNearest(decimal) {
   return decimal.toDecimalPlaces(0, Decimal3.ROUND_HALF_CEIL);
 }
+var SinglePoolInstruction = {
+  initializePool: (voteAccount) => {
+    const pool = findPoolAddress(voteAccount);
+    const stake = findPoolStakeAddress(pool);
+    const mint = findPoolMintAddress(pool);
+    const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+    const mintAuthority = findPoolMintAuthorityAddress(pool);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: voteAccount, isSigner: false, isWritable: false },
+        { pubkey: pool, isSigner: false, isWritable: true },
+        { pubkey: stake, isSigner: false, isWritable: true },
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: stakeAuthority, isSigner: false, isWritable: false },
+        { pubkey: mintAuthority, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_RENT_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_CLOCK_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_STAKE_HISTORY_ID, isSigner: false, isWritable: false },
+        { pubkey: STAKE_CONFIG_ID$1, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: STAKE_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      Buffer.from([0 /* InitializePool */])
+    );
+  },
+  initializeOnRamp: (pool) => {
+    const onRamp = findPoolOnRampAddress(pool);
+    const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: pool, isSigner: false, isWritable: false },
+        { pubkey: onRamp, isSigner: false, isWritable: true },
+        { pubkey: stakeAuthority, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_RENT_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: STAKE_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      Buffer.from([6 /* InitializeOnRamp */])
+    );
+  },
+  depositStake: async (pool, userStakeAccount, userTokenAccount, userLamportAccount) => {
+    const stake = findPoolStakeAddress(pool);
+    const onRamp = findPoolOnRampAddress(pool);
+    const mint = findPoolMintAddress(pool);
+    const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+    const mintAuthority = findPoolMintAuthorityAddress(pool);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: pool, isSigner: false, isWritable: false },
+        { pubkey: stake, isSigner: false, isWritable: true },
+        { pubkey: onRamp, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: stakeAuthority, isSigner: false, isWritable: false },
+        { pubkey: mintAuthority, isSigner: false, isWritable: false },
+        { pubkey: userStakeAccount, isSigner: false, isWritable: true },
+        { pubkey: userTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: userLamportAccount, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_CLOCK_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_STAKE_HISTORY_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: STAKE_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      Buffer.from([2 /* DepositStake */])
+    );
+  },
+  withdrawStake: async (pool, userStakeAccount, userStakeAuthority, userTokenAccount, tokenAmount) => {
+    const stake = findPoolStakeAddress(pool);
+    const onRamp = findPoolOnRampAddress(pool);
+    const mint = findPoolMintAddress(pool);
+    const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+    const mintAuthority = findPoolMintAuthorityAddress(pool);
+    const rawAmount = BigInt(tokenAmount.multipliedBy(1e9).toString());
+    const data = Buffer.concat([
+      Buffer.from([3 /* WithdrawStake */]),
+      userStakeAuthority.toBuffer(),
+      Buffer.from(new BN(rawAmount.toString()).toArray("le", 8))
+    ]);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: pool, isSigner: false, isWritable: false },
+        { pubkey: stake, isSigner: false, isWritable: true },
+        { pubkey: onRamp, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: stakeAuthority, isSigner: false, isWritable: false },
+        { pubkey: mintAuthority, isSigner: false, isWritable: false },
+        { pubkey: userStakeAccount, isSigner: false, isWritable: true },
+        { pubkey: userTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_CLOCK_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: STAKE_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      data
+    );
+  },
+  createTokenMetadata: async (pool, payer) => {
+    const mint = findPoolMintAddress(pool);
+    const [mintAuthority, mplAuthority, mplMetadata] = await Promise.all([
+      findPoolMintAuthorityAddress(pool),
+      findPoolMplAuthorityAddress(pool),
+      findMplMetadataAddress(mint)
+    ]);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: pool, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: mintAuthority, isSigner: false, isWritable: false },
+        { pubkey: mplAuthority, isSigner: false, isWritable: false },
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: mplMetadata, isSigner: false, isWritable: true },
+        { pubkey: MPL_METADATA_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      Buffer.from([4 /* CreateTokenMetadata */])
+    );
+  },
+  updateTokenMetadata: async (voteAccount, authorizedWithdrawer, tokenName, tokenSymbol, tokenUri = "") => {
+    if (tokenName.length > 32) {
+      throw new Error("maximum token name length is 32 characters");
+    }
+    if (tokenSymbol.length > 10) {
+      throw new Error("maximum token symbol length is 10 characters");
+    }
+    if (tokenUri.length > 200) {
+      throw new Error("maximum token uri length is 200 characters");
+    }
+    const pool = findPoolAddress(voteAccount);
+    const [mint, mplAuthority] = await Promise.all([
+      findPoolMintAddress(pool),
+      findPoolMplAuthorityAddress(pool)
+    ]);
+    const mplMetadata = await findMplMetadataAddress(mint);
+    const data = Buffer.concat([
+      Buffer.from([5 /* UpdateTokenMetadata */]),
+      Buffer.from(new Uint32Array([tokenName.length]).buffer),
+      Buffer.from(tokenName),
+      Buffer.from(new Uint32Array([tokenSymbol.length]).buffer),
+      Buffer.from(tokenSymbol),
+      Buffer.from(new Uint32Array([tokenUri.length]).buffer),
+      Buffer.from(tokenUri)
+    ]);
+    return createTransactionInstruction(
+      SINGLE_POOL_PROGRAM_ID,
+      [
+        { pubkey: voteAccount, isSigner: false, isWritable: false },
+        { pubkey: pool, isSigner: false, isWritable: false },
+        { pubkey: mplAuthority, isSigner: false, isWritable: false },
+        { pubkey: authorizedWithdrawer, isSigner: true, isWritable: false },
+        { pubkey: mplMetadata, isSigner: false, isWritable: true },
+        { pubkey: MPL_METADATA_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      data
+    );
+  }
+};
+var createTransactionInstruction = (programId, keys, data) => {
+  return {
+    programId,
+    keys,
+    data
+  };
+};
 var findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
   const [pda] = PublicKey.findProgramAddressSync(
     [Buffer.from(prefix), baseAddress.toBuffer()],
@@ -43361,7 +43556,17 @@ var findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
 var findPoolAddress = (voteAccountAddress) => findPda(voteAccountAddress, "pool");
 var findPoolMintAddress = (poolAddress) => findPda(poolAddress, "mint");
 var findPoolStakeAddress = (poolAddress) => findPda(poolAddress, "stake");
+var findPoolStakeAuthorityAddress = (poolAddress) => findPda(poolAddress, "stake_authority");
+var findPoolMintAuthorityAddress = (poolAddress) => findPda(poolAddress, "mint_authority");
+var findPoolMplAuthorityAddress = (poolAddress) => findPda(poolAddress, "mpl_authority");
 var findPoolOnRampAddress = (poolAddress) => findPda(poolAddress, "onramp");
+var findMplMetadataAddress = async (poolMintAddress) => {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("metadata"), MPL_METADATA_PROGRAM_ID.toBuffer(), poolMintAddress.toBuffer()],
+    MPL_METADATA_PROGRAM_ID
+  );
+  return pda;
+};
 BigInt(33);
 BigInt(200);
 BigInt(82);
@@ -44142,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 ---
@@ -46148,10 +46369,11 @@ async function makeBorrowIx3({
     );
     borrowIxs.push(createAtaIdempotentIx);
   }
+  const mandatoryBanks = [bank.address, ...opts.additionalHealthCheckBanks ?? []];
   const healthAccounts = computeHealthCheckAccounts(
     marginfiAccount.balances,
     bankMap,
-    [bank.address],
+    mandatoryBanks,
     []
   );
   const remainingAccounts = [];
@@ -46686,81 +46908,116 @@ async function makeJuplendDepositTx(params) {
   });
   return solanaTx;
 }
-async function makeRepayIx3({
-  program,
-  bank,
-  tokenProgram,
-  amount,
-  authority,
-  accountAddress,
-  repayAll = false,
-  isSync = false,
-  opts = {}
-}) {
-  const wrapAndUnwrapSol = opts.wrapAndUnwrapSol ?? true;
-  const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
-  const repayIxs = [];
-  const userAta = getAssociatedTokenAddressSync(bank.mint, authority, true, tokenProgram);
-  const remainingAccounts = tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? [{ pubkey: bank.mint, isSigner: false, isWritable: false }] : [];
-  if (bank.mint.equals(NATIVE_MINT) && wrapAndUnwrapSol) {
-    repayIxs.push(...makeWrapSolIxs(authority, new BigNumber(amount).minus(wSolBalanceUi)));
-  }
-  const repayIx = !isSync || !opts.overrideInferAccounts?.group ? await instructions_default.makeRepayIx(
+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: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group,
-      liquidityVault: opts.overrideInferAccounts?.liquidityVault
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
-  ) : sync_instructions_default.makeRepayIx(
+    { 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: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
+    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
+    }))
   );
-  repayIxs.push(repayIx);
-  return {
-    instructions: repayIxs,
-    keys: []
-  };
+  return { instructions: [ix], keys: [] };
 }
-async function makeRepayTx(params) {
-  const { luts, ...depositIxParams } = params;
-  const ixs = await makeRepayIx3(depositIxParams);
-  const tx = new Transaction().add(...ixs.instructions);
-  tx.feePayer = params.authority;
-  const solanaTx = addTransactionMetadata(tx, {
-    type: "REPAY" /* REPAY */,
-    signers: ixs.keys,
-    addressLookupTables: luts
+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;
   });
-  return solanaTx;
+  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;
 }
-async function makeRepayWithCollatTx(params) {
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    withdrawOpts,
-    repayOpts,
+    depositOpts,
+    borrowOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl
+    crossbarUrl,
+    additionalIxs = []
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -46768,34 +47025,34 @@ async function makeRepayWithCollatTx(params) {
     authority: marginfiAccount.authority,
     tokens: [
       {
-        mint: repayOpts.repayBank.mint,
-        tokenProgram: repayOpts.tokenProgram
+        mint: borrowOpts.borrowBank.mint,
+        tokenProgram: borrowOpts.tokenProgram
       },
       {
-        mint: withdrawOpts.withdrawBank.mint,
-        tokenProgram: withdrawOpts.tokenProgram
+        mint: depositOpts.depositBank.mint,
+        tokenProgram: depositOpts.tokenProgram
       }
     ]
   });
-  const updateJuplendMarketIxs = makeUpdateJupLendRateIxs(
-    marginfiAccount,
-    bankMap,
-    [withdrawOpts.withdrawBank.address],
-    bankMetadataMap
+  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
   );
   const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    marginfiAccount,
-    bankMap,
-    [withdrawOpts.withdrawBank.address],
-    bankMetadataMap
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
   );
   const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
     marginfiAccount,
     bankMap,
-    [withdrawOpts.withdrawBank.address, repayOpts.repayBank.address],
+    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
     bankMetadataMap
   );
-  const { flashloanTx, setupInstructions, swapQuote, amountToRepay, withdrawIxs, repayIxs } = await buildRepayWithCollatFlashloanTx({
+  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
     ...params,
     blockhash
   });
@@ -46805,7 +47062,7 @@ async function makeRepayWithCollatTx(params) {
     }
     if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
       const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(repayOpts.repayBank.mint)) {
+      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
         return false;
       }
     }
@@ -46817,18 +47074,24 @@ async function makeRepayWithCollatTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...withdrawIxs.instructions, ...repayIxs.instructions],
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
     program,
     connection,
     crossbarUrl
   });
   let additionalTxs = [];
-  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
+  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,
-      ...updateJuplendMarketIxs.instructions
+      ...updateJupLendRateIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -46858,16 +47121,19 @@ async function makeRepayWithCollatTx(params) {
     );
   }
   const transactions = [...additionalTxs, flashloanTx];
-  return { transactions, swapQuote, amountToRepay };
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
 }
-async function buildRepayWithCollatFlashloanTx({
+async function buildLoopFlashloanTx({
   program,
   marginfiAccount,
   bankMap,
-  withdrawOpts,
-  repayOpts,
+  borrowOpts,
+  depositOpts,
   bankMetadataMap,
-  assetShareValueMultiplierByBank,
   addressLookupTableAccounts,
   connection,
   swapOpts,
@@ -46878,20 +47144,20 @@ async function buildRepayWithCollatFlashloanTx({
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
-  let amountToRepay;
+  let amountToDeposit;
   let swapInstructions = [];
   let setupInstructions = [];
   let swapLookupTables = [];
   let swapQuote;
   let sizeConstraintUsed = 0;
-  if (repayOpts.repayBank.mint.equals(withdrawOpts.withdrawBank.mint)) {
-    amountToRepay = withdrawOpts.withdrawAmount;
+  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
+    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new PublicKey(repayOpts.repayBank.mint),
+      new PublicKey(depositOpts.depositBank.mint),
       marginfiAccount.authority,
       true,
-      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
     const swapConstraints = await computeFlashloanSwapConstraints({
       program,
@@ -46900,24 +47166,21 @@ async function buildRepayWithCollatFlashloanTx({
       bankMetadataMap,
       addressLookupTableAccounts: addressLookupTableAccounts ?? [],
       primaryIx: {
-        type: "withdraw",
-        bank: withdrawOpts.withdrawBank,
-        tokenProgram: withdrawOpts.tokenProgram
+        type: "borrow",
+        bank: borrowOpts.borrowBank,
+        tokenProgram: borrowOpts.tokenProgram
       },
       secondaryIx: {
-        type: "repay",
-        bank: repayOpts.repayBank,
-        tokenProgram: repayOpts.tokenProgram
+        type: "deposit",
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram
       },
       overrideInferAccounts
     });
     const swapResponse = await getSwapIxsForFlashloan({
-      inputMint: withdrawOpts.withdrawBank.mint.toBase58(),
-      outputMint: repayOpts.repayBank.mint.toBase58(),
-      amount: uiToNative(
-        withdrawOpts.withdrawAmount,
-        withdrawOpts.withdrawBank.mintDecimals
-      ).toNumber(),
+      inputMint: borrowOpts.borrowBank.mint.toBase58(),
+      outputMint: depositOpts.depositBank.mint.toBase58(),
+      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
       swapMode: "ExactIn",
       authority: marginfiAccount.authority,
       connection,
@@ -46927,50 +47190,52 @@ async function buildRepayWithCollatFlashloanTx({
       maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
     sizeConstraintUsed = swapConstraints.sizeConstraint;
-    const { quoteResponse } = swapResponse;
-    const outAmount = nativeToUi(quoteResponse.outAmount, repayOpts.repayBank.mintDecimals);
     const outAmountThreshold = nativeToUi(
-      quoteResponse.otherAmountThreshold,
-      repayOpts.repayBank.mintDecimals
+      swapResponse.quoteResponse.otherAmountThreshold,
+      depositOpts.depositBank.mintDecimals
     );
-    amountToRepay = outAmount > repayOpts.totalPositionAmount ? repayOpts.totalPositionAmount : outAmountThreshold;
+    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
     swapInstructions = swapResponse.swapInstructions;
+    setupInstructions = swapResponse.setupInstructions;
     swapLookupTables = swapResponse.addressLookupTableAddresses;
-    swapQuote = quoteResponse;
+    swapQuote = swapResponse.quoteResponse;
   }
-  let withdrawIxs;
-  switch (withdrawOpts.withdrawBank.config.assetTag) {
+  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[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
+      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
       if (!reserve) {
         throw TransactionBuildingError.kaminoReserveNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
         );
       }
-      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
-      const adjustedAmount = new BigNumber(withdrawOpts.withdrawAmount).div(multiplier).times(1.0001).toNumber();
-      withdrawIxs = await makeKaminoWithdrawIx3({
+      depositIxs = await makeKaminoDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        cTokenAmount: adjustedAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
         reserve,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -46978,35 +47243,27 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.driftStates;
+      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
       if (!driftState) {
         throw TransactionBuildingError.driftStateNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
         );
       }
-      withdrawIxs = await makeDriftWithdrawIx3({
+      const driftMarketIndex = driftState.spotMarketState.marketIndex;
+      const driftOracle = driftState.spotMarketState.oracle;
+      depositIxs = await makeDriftDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
-        driftSpotMarket: driftState.spotMarketState,
-        userRewards: driftState.userRewards,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
+        group: marginfiAccount.group,
+        driftMarketIndex,
+        driftOracle,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47014,679 +47271,156 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     case 6 /* JUPLEND */: {
-      const jupLendState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.jupLendStates;
-      if (!jupLendState) {
-        throw TransactionBuildingError.jupLendStateNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
-        );
-      }
-      withdrawIxs = await makeJuplendWithdrawIx2({
-        program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        opts: {
-          createAtas: false,
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    default: {
-      withdrawIxs = await makeWithdrawIx3({
+      depositIxs = await makeJuplendDepositIx2({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
+        group: marginfiAccount.group,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
       });
       break;
     }
-  }
-  const repayIxs = await makeRepayIx3({
-    program,
-    bank: repayOpts.repayBank,
-    tokenProgram: repayOpts.tokenProgram,
-    amount: amountToRepay,
-    accountAddress: marginfiAccount.address,
-    authority: marginfiAccount.authority,
-    repayAll: isWholePosition(
-      {
-        amount: repayOpts.totalPositionAmount,
-        isLending: true
-      },
-      amountToRepay,
-      repayOpts.repayBank.mintDecimals
-    ),
-    isSync: false,
-    opts: {
-      wrapAndUnwrapSol: false,
-      overrideInferAccounts
-    }
-  });
-  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-  const allNonFlIxs = [
-    ...cuRequestIxs,
-    ...withdrawIxs.instructions,
-    ...swapInstructions,
-    ...repayIxs.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,
-    isSync: true
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededRepay(
-      txSize,
-      totalKeys,
-      swapOpts.swapConfig?.provider
-    );
-  }
-  return {
-    flashloanTx,
-    setupInstructions,
-    swapQuote,
-    withdrawIxs,
-    repayIxs,
-    amountToRepay
-  };
-}
-
-// 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({
+      depositIxs = await makeDepositIx3({
         program,
-        bank,
-        tokenProgram,
-        amount: 1,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
         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
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
       });
+      break;
     }
   }
-}
-async function computeFlashloanSwapConstraints({
-  program,
-  marginfiAccount,
-  bankMap,
-  addressLookupTableAccounts,
-  bankMetadataMap,
-  primaryIx,
-  secondaryIx,
-  overrideInferAccounts
-}) {
-  const cuRequestIxs = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...swapInstructions,
+    ...depositIxs.instructions
   ];
-  const [primaryResult, secondaryResult] = await Promise.all([
-    buildBudgetIx(
-      primaryIx,
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      overrideInferAccounts
-    ),
-    buildBudgetIx(
-      secondaryIx,
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      overrideInferAccounts
-    )
-  ]);
-  return computeFlashLoanNonSwapBudget({
+  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,
-    ixs: [...cuRequestIxs, ...primaryResult.instructions, ...secondaryResult.instructions]
+    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/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(
+async function makeRepayIx3({
+  program,
+  bank,
+  tokenProgram,
+  amount,
+  authority,
+  accountAddress,
+  repayAll = false,
+  isSync = false,
+  opts = {}
+}) {
+  const wrapAndUnwrapSol = opts.wrapAndUnwrapSol ?? true;
+  const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
+  const repayIxs = [];
+  const userAta = getAssociatedTokenAddressSync(bank.mint, authority, true, tokenProgram);
+  const remainingAccounts = tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? [{ pubkey: bank.mint, isSigner: false, isWritable: false }] : [];
+  if (bank.mint.equals(NATIVE_MINT) && wrapAndUnwrapSol) {
+    repayIxs.push(...makeWrapSolIxs(authority, new BigNumber(amount).minus(wSolBalanceUi)));
+  }
+  const repayIx = !isSync || !opts.overrideInferAccounts?.group ? await instructions_default.makeRepayIx(
     program,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group,
+      liquidityVault: opts.overrideInferAccounts?.liquidityVault
     },
-    { 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(
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
+  ) : sync_instructions_default.makeRepayIx(
     program.programId,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  ) : await instructions_default.makeEndFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group
     },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
   );
-  return { instructions: [ix], keys: [] };
+  repayIxs.push(repayIx);
+  return {
+    instructions: repayIxs,
+    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
+async function makeRepayTx(params) {
+  const { luts, ...depositIxParams } = params;
+  const ixs = await makeRepayIx3(depositIxParams);
+  const tx = new Transaction().add(...ixs.instructions);
+  tx.feePayer = params.authority;
+  const solanaTx = addTransactionMetadata(tx, {
+    type: "REPAY" /* REPAY */,
+    signers: ixs.keys,
+    addressLookupTables: luts
   });
-  if (signers) {
-    tx.sign(signers);
-  }
-  return tx;
+  return solanaTx;
 }
-
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
+async function makeRepayWithCollatTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    depositOpts,
-    borrowOpts,
+    withdrawOpts,
+    repayOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
+    crossbarUrl
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -47694,34 +47428,34 @@ async function makeLoopTx(params) {
     authority: marginfiAccount.authority,
     tokens: [
       {
-        mint: borrowOpts.borrowBank.mint,
-        tokenProgram: borrowOpts.tokenProgram
+        mint: repayOpts.repayBank.mint,
+        tokenProgram: repayOpts.tokenProgram
       },
       {
-        mint: depositOpts.depositBank.mint,
-        tokenProgram: depositOpts.tokenProgram
+        mint: withdrawOpts.withdrawBank.mint,
+        tokenProgram: withdrawOpts.tokenProgram
       }
     ]
   });
-  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
+  const updateJuplendMarketIxs = makeUpdateJupLendRateIxs(
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address],
+    bankMetadataMap
   );
   const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address],
+    bankMetadataMap
   );
   const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
     marginfiAccount,
     bankMap,
-    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
+    [withdrawOpts.withdrawBank.address, repayOpts.repayBank.address],
     bankMetadataMap
   );
-  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
+  const { flashloanTx, setupInstructions, swapQuote, amountToRepay, withdrawIxs, repayIxs } = await buildRepayWithCollatFlashloanTx({
     ...params,
     blockhash
   });
@@ -47731,7 +47465,7 @@ async function makeLoopTx(params) {
     }
     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)) {
+      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(repayOpts.repayBank.mint)) {
         return false;
       }
     }
@@ -47743,24 +47477,18 @@ async function makeLoopTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    instructions: [...withdrawIxs.instructions, ...repayIxs.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) {
+  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
     const ixs = [
-      ...additionalIxs,
       ...setupIxs,
       ...kaminoRefreshIxs.instructions,
       ...updateDriftMarketIxs.instructions,
-      ...updateJupLendRateIxs.instructions
+      ...updateJuplendMarketIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -47790,19 +47518,16 @@ async function makeLoopTx(params) {
     );
   }
   const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
+  return { transactions, swapQuote, amountToRepay };
 }
-async function buildLoopFlashloanTx({
+async function buildRepayWithCollatFlashloanTx({
   program,
   marginfiAccount,
   bankMap,
-  borrowOpts,
-  depositOpts,
+  withdrawOpts,
+  repayOpts,
   bankMetadataMap,
+  assetShareValueMultiplierByBank,
   addressLookupTableAccounts,
   connection,
   swapOpts,
@@ -47813,20 +47538,20 @@ async function buildLoopFlashloanTx({
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
-  let amountToDeposit;
+  let amountToRepay;
   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);
+  if (repayOpts.repayBank.mint.equals(withdrawOpts.withdrawBank.mint)) {
+    amountToRepay = withdrawOpts.withdrawAmount;
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new PublicKey(depositOpts.depositBank.mint),
+      new PublicKey(repayOpts.repayBank.mint),
       marginfiAccount.authority,
       true,
-      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
     const swapConstraints = await computeFlashloanSwapConstraints({
       program,
@@ -47835,21 +47560,24 @@ async function buildLoopFlashloanTx({
       bankMetadataMap,
       addressLookupTableAccounts: addressLookupTableAccounts ?? [],
       primaryIx: {
-        type: "borrow",
-        bank: borrowOpts.borrowBank,
-        tokenProgram: borrowOpts.tokenProgram
+        type: "withdraw",
+        bank: withdrawOpts.withdrawBank,
+        tokenProgram: withdrawOpts.tokenProgram
       },
       secondaryIx: {
-        type: "deposit",
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram
+        type: "repay",
+        bank: repayOpts.repayBank,
+        tokenProgram: repayOpts.tokenProgram
       },
       overrideInferAccounts
     });
     const swapResponse = await getSwapIxsForFlashloan({
-      inputMint: borrowOpts.borrowBank.mint.toBase58(),
-      outputMint: depositOpts.depositBank.mint.toBase58(),
-      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
+      inputMint: withdrawOpts.withdrawBank.mint.toBase58(),
+      outputMint: repayOpts.repayBank.mint.toBase58(),
+      amount: uiToNative(
+        withdrawOpts.withdrawAmount,
+        withdrawOpts.withdrawBank.mintDecimals
+      ).toNumber(),
       swapMode: "ExactIn",
       authority: marginfiAccount.authority,
       connection,
@@ -47859,52 +47587,50 @@ async function buildLoopFlashloanTx({
       maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
     sizeConstraintUsed = swapConstraints.sizeConstraint;
+    const { quoteResponse } = swapResponse;
+    const outAmount = nativeToUi(quoteResponse.outAmount, repayOpts.repayBank.mintDecimals);
     const outAmountThreshold = nativeToUi(
-      swapResponse.quoteResponse.otherAmountThreshold,
-      depositOpts.depositBank.mintDecimals
+      quoteResponse.otherAmountThreshold,
+      repayOpts.repayBank.mintDecimals
     );
-    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
+    amountToRepay = outAmount > repayOpts.totalPositionAmount ? repayOpts.totalPositionAmount : outAmountThreshold;
     swapInstructions = swapResponse.swapInstructions;
-    setupInstructions = swapResponse.setupInstructions;
     swapLookupTables = swapResponse.addressLookupTableAddresses;
-    swapQuote = swapResponse.quoteResponse;
+    swapQuote = 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) {
+  let withdrawIxs;
+  switch (withdrawOpts.withdrawBank.config.assetTag) {
     case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
+      const reserve = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
       if (!reserve) {
         throw TransactionBuildingError.kaminoReserveNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
         );
       }
-      depositIxs = await makeKaminoDepositIx3({
+      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
+      const adjustedAmount = new BigNumber(withdrawOpts.withdrawAmount).div(multiplier).times(1.0001).toNumber();
+      withdrawIxs = await makeKaminoWithdrawIx3({
         program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        cTokenAmount: adjustedAmount,
+        marginfiAccount,
         authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
         reserve,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
         opts: {
+          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47912,27 +47638,35 @@ async function buildLoopFlashloanTx({
       break;
     }
     case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
+      const driftState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.driftStates;
       if (!driftState) {
         throw TransactionBuildingError.driftStateNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
         );
       }
-      const driftMarketIndex = driftState.spotMarketState.marketIndex;
-      const driftOracle = driftState.spotMarketState.oracle;
-      depositIxs = await makeDriftDepositIx3({
+      withdrawIxs = await makeDriftWithdrawIx3({
         program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
         authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex,
-        driftOracle,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
         opts: {
+          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47940,15 +47674,33 @@ async function buildLoopFlashloanTx({
       break;
     }
     case 6 /* JUPLEND */: {
-      depositIxs = await makeJuplendDepositIx2({
+      const jupLendState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.jupLendStates;
+      if (!jupLendState) {
+        throw TransactionBuildingError.jupLendStateNotFound(
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
+        );
+      }
+      withdrawIxs = await makeJuplendWithdrawIx2({
         program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
         authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
+        jupLendingState: jupLendState.jupLendingState,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
         opts: {
+          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47956,15 +47708,25 @@ async function buildLoopFlashloanTx({
       break;
     }
     default: {
-      depositIxs = await makeDepositIx3({
+      withdrawIxs = await makeWithdrawIx3({
         program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
         authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
         opts: {
+          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47972,12 +47734,33 @@ async function buildLoopFlashloanTx({
       break;
     }
   }
+  const repayIxs = await makeRepayIx3({
+    program,
+    bank: repayOpts.repayBank,
+    tokenProgram: repayOpts.tokenProgram,
+    amount: amountToRepay,
+    accountAddress: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    repayAll: isWholePosition(
+      {
+        amount: repayOpts.totalPositionAmount,
+        isLending: true
+      },
+      amountToRepay,
+      repayOpts.repayBank.mintDecimals
+    ),
+    isSync: false,
+    opts: {
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
+  });
   const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
   const allNonFlIxs = [
     ...cuRequestIxs,
-    ...borrowIxs.instructions,
+    ...withdrawIxs.instructions,
     ...swapInstructions,
-    ...depositIxs.instructions
+    ...repayIxs.instructions
   ];
   if (swapInstructions.length > 0) {
     compileFlashloanPrecheck({
@@ -47995,12 +47778,13 @@ async function buildLoopFlashloanTx({
     bankMap,
     addressLookupTableAccounts: luts,
     blockhash,
-    ixs: allNonFlIxs
+    ixs: allNonFlIxs,
+    isSync: true
   });
   const txSize = getTxSize(flashloanTx);
   const totalKeys = getTotalAccountKeys(flashloanTx);
   if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
+    throw TransactionBuildingError.swapSizeExceededRepay(
       txSize,
       totalKeys,
       swapOpts.swapConfig?.provider
@@ -48010,9 +47794,9 @@ async function buildLoopFlashloanTx({
     flashloanTx,
     setupInstructions,
     swapQuote,
-    borrowIxs,
-    depositIxs,
-    amountToDeposit
+    withdrawIxs,
+    repayIxs,
+    amountToRepay
   };
 }
 
@@ -48200,7 +47984,7 @@ async function buildSwapCollateralFlashloanTx({
         authority: marginfiAccount.authority,
         reserve,
         withdrawAll: isFullWithdraw,
-        isSync: true,
+        isSync: false,
         opts: {
           createAtas: false,
           wrapAndUnwrapSol: false,
@@ -48275,7 +48059,7 @@ async function buildSwapCollateralFlashloanTx({
         marginfiAccount,
         authority: marginfiAccount.authority,
         withdrawAll: isFullWithdraw,
-        isSync: true,
+        isSync: false,
         opts: {
           createAtas: false,
           wrapAndUnwrapSol: false,
@@ -48438,12 +48222,12 @@ async function buildSwapCollateralFlashloanTx({
     addressLookupTableAccounts: luts,
     blockhash,
     ixs: allNonFlIxs,
-    isSync: true
+    isSync: false
   });
   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
@@ -48704,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
@@ -49374,23 +49158,27 @@ var getTitanSwapIxsForFlashloan = async ({
     quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint
   );
   const { feeAccount, hasFeeAccount } = await checkTitanFeeAccount(connection, feeMint);
+  const useFeeAccount = hasFeeAccount && !!quoteParams.platformFeeBps;
   let finalQuoteParams = quoteParams;
-  if (!hasFeeAccount) {
-    console.warn("Warning: Titan fee account ATA does not exist, disabling platform fee");
+  if (!useFeeAccount) {
+    if (!hasFeeAccount) {
+      console.warn("Warning: Titan fee account ATA does not exist, disabling platform fee");
+    }
     finalQuoteParams = {
       ...quoteParams,
       platformFeeBps: void 0
     };
   }
+  const effectiveFeeAccount = useFeeAccount ? feeAccount : void 0;
   if (basePath.startsWith("wss://") || basePath.startsWith("ws://")) {
     return getTitanSwapIxsViaWebSocket(
       { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
-      hasFeeAccount ? feeAccount : void 0
+      effectiveFeeAccount
     );
   } else {
     return getTitanSwapIxsViaHttpProxy(
       { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
-      hasFeeAccount ? feeAccount : void 0
+      effectiveFeeAccount
     );
   }
 };
@@ -49566,7 +49354,7 @@ async function getTitanExactOutViaWebSocket(params) {
         inputMint: new PublicKey(inputMint).toBytes(),
         outputMint: new PublicKey(outputMint).toBytes(),
         amount,
-        swapMode: "ExactOut",
+        swapMode: "ExactOut" /* ExactOut */,
         slippageBps
       },
       transaction: {
@@ -49786,178 +49574,616 @@ var getSwapIxsForFlashloan = async (params) => {
       lastError = err;
       console.warn(`[swap] ${attemptProvider} failed:`, err instanceof Error ? err.message : err);
     }
-  }
-  const firstProvider = attempts[0]?.provider ?? "Swap";
-  throw TransactionBuildingError.swapQuoteFailed(
-    firstProvider,
-    inputMint,
-    outputMint,
-    lastError?.message ?? "No swap route available"
-  );
-};
-var getExactOutEstimate = async (params) => {
-  const { inputMint, outputMint, amount, swapOpts, connection } = params;
-  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
-  const attempts = [
-    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
-    ...swapOpts.swapConfig?.fallbackProviders ?? []
-  ];
-  let lastError;
-  for (const { provider: attemptProvider, apiConfig } of attempts) {
-    const fn = getExactOutProviderFn({
-      attemptProvider,
-      inputMint,
-      outputMint,
-      amount,
-      swapOpts,
-      apiConfig
-    });
-    if (!fn) continue;
-    try {
-      return await fn(apiConfig);
-    } catch (err) {
-      if (err instanceof TransactionBuildingError) throw err;
-      lastError = err;
-      console.warn(
-        `[exactout] ${attemptProvider} failed:`,
-        err instanceof Error ? err.message : err
-      );
+  }
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+var getExactOutEstimate = async (params) => {
+  const { inputMint, outputMint, amount, swapOpts, connection } = params;
+  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
+  const attempts = [
+    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
+    ...swapOpts.swapConfig?.fallbackProviders ?? []
+  ];
+  let lastError;
+  for (const { provider: attemptProvider, apiConfig } of attempts) {
+    const fn = getExactOutProviderFn({
+      attemptProvider,
+      inputMint,
+      outputMint,
+      amount,
+      swapOpts,
+      apiConfig
+    });
+    if (!fn) continue;
+    try {
+      return await fn(apiConfig);
+    } catch (err) {
+      if (err instanceof TransactionBuildingError) throw err;
+      lastError = err;
+      console.warn(
+        `[exactout] ${attemptProvider} failed:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  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;
+  const useFeeAccount = hasFeeAccount && !!quoteParams.platformFeeBps;
+  let finalQuoteParams = quoteParams;
+  if (!useFeeAccount) {
+    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: useFeeAccount ? 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
+      });
     }
   }
-  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 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
@@ -50625,18 +50851,15 @@ var fetchPythOracleData = async (banks, opts) => {
       bankOraclePriceMap: /* @__PURE__ */ new Map()
     };
   }
-  pythStakedCollateralBanks.map((bank) => [
-    opts.validatorVoteAccountByBank?.[bank.address.toBase58()] ?? "",
-    bank.mint.toBase58()
-  ]);
-  const priceCoeffByBank = {};
   const combinedPythBanks = [
     ...pythPushBanks,
+    ...pythStakedCollateralBanks,
     ...pythPushKaminosBanks,
     ...driftPythPullBanks,
     ...solendPythPullBanks,
     ...juplendPythPullBanks
   ];
+  const priceCoeffByBank = {};
   const pythOracleKeys = extractPythOracleKeys(combinedPythBanks);
   const uniquePythOracleKeys = Array.from(new Set(pythOracleKeys));
   let oraclePrices;
@@ -51440,6 +51663,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;
@@ -51841,6 +52136,613 @@ function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
     }))
   };
 }
+
+// src/services/native-stake/utils/metadata.data.ts
+var STAKED_BANK_METADATA_JSON = [
+  {
+    bankAddress: "8g5qG6PVygcVSXV1cJnjXaD1yhrDwcWAMQCY2wR9VuAf",
+    validatorVoteAccount: "CooLbbZy5Xmdt7DiHPQ3ss2uRXawnTXXVgpMS8E8jDzr",
+    tokenAddress: "BADo3D6nMtGnsAaTv3iEes8mMcq92TuFoBWebFe8kzeA",
+    tokenName: "Cavey Cool",
+    tokenSymbol: "COOL"
+  },
+  {
+    bankAddress: "BuCckNm1djpp3vZVhvh1CrrniirY6sr2hwUmeP5kTcGz",
+    validatorVoteAccount: "mrgn4t2JabSgvGnrCaHXMvz8ocr4F52scsxJnkQMQsQ",
+    tokenAddress: "FUyAyVbYrMfiaN1QEQYFZTuBNzW5EJf3jWzjjymGqKLv",
+    tokenName: "Project 0 Meridian",
+    tokenSymbol: "MERIDIAN"
+  },
+  {
+    bankAddress: "Hco1P3dGRXz3ZGFvMkbDgghZQy47Tp7vp7koSYRvP6nm",
+    validatorVoteAccount: "mrgn6ETrBDM8mjjYN8rbVwFqVwF8z6rtmvGLbdGuVUU",
+    tokenAddress: "A4B5MGQvcZCUqeiUEAB4ckZ2tvH2UmEg31vF7TiERDkH",
+    tokenName: "MRGN 3",
+    tokenSymbol: "MRGN3"
+  },
+  {
+    bankAddress: "EPh2abWP8DusPH8myWnECAAeQUZgAz927aMbmwXt3eRY",
+    validatorVoteAccount: "mrgn2vsZ5EJ8YEfAMNPXmRux7th9cNfBasQ1JJvVwPn",
+    tokenAddress: "6Mt7tBWLUJfDxqCFTsjoRXF9wD55g4Lhs5nAyYp244pX",
+    tokenName: "Project 0 Horizon",
+    tokenSymbol: "HORIZON"
+  },
+  {
+    bankAddress: "6wjAwhnxTMEzHk8NNHVXgkx1jSrb6TX1bC17j3S56FfB",
+    validatorVoteAccount: "3N7s9zXMZ4QqvHQR15t5GNHyqc89KduzMP7423eWiD5g",
+    tokenAddress: "DKPvRV4dxUejjGpr2XwFmzZbbbTD7vx9Jmt1kk43n4d5",
+    tokenName: "Binance",
+    tokenSymbol: "BINANCE"
+  },
+  {
+    bankAddress: "J9tksvZEDSwtNtZ6yxYjWDDkzhPbwDMnihU61NkFG9FE",
+    validatorVoteAccount: "he1iusunGwqrNtafDtLdhsUQDFvo13z9sUa36PauBtk",
+    tokenAddress: "2k79y8CApbU9jAvWhLS2j6uRbaVjpLJTUzstBTho9vGq",
+    tokenName: "Helius",
+    tokenSymbol: "HELIUS"
+  },
+  {
+    bankAddress: "Dfr6Sf44ftecaJaoJMzFQABdkt3CEHfBwut1WyacRzaE",
+    validatorVoteAccount: "SLaYv7tCwetrFGbPCRnqpHswG5qqKino78EYpbGF7xY",
+    tokenAddress: "Vsw4JT33S7bLbhjySMMyrP3JKvTAcNi9WG5Doekrmgg",
+    tokenName: "Solayer",
+    tokenSymbol: "SOLAYER"
+  },
+  {
+    bankAddress: "BZAm4qGscR8gg5bmWrEq6BTofgaZPbg7Fwfa7rFghEXL",
+    validatorVoteAccount: "J1to3PQfXidUUhprQWgdKkQAMWPJAEqSJ7amkBDE9qhF",
+    tokenAddress: "6B8hZSupE5mcACmjzozP6C1DR2uaCCtmrGqcYWC6SBCc",
+    tokenName: "Bonk",
+    tokenSymbol: "BONK"
+  },
+  {
+    bankAddress: "3UrMZ26NRKu2y6c2dPE7gZVHwEmhpwKLcWACg3tjCVEt",
+    validatorVoteAccount: "J2nUHEAgZFRyuJbFjdqPrAa9gyWDuc7hErtDQHPhsYRp",
+    tokenAddress: "9M7oMo4oL6RDPG7WbAX3Zz4dPzbMgpiCzwrQPMwG4Wgq",
+    tokenName: "Phantom",
+    tokenSymbol: "PHANTOM"
+  },
+  {
+    bankAddress: "8c269gkonvATm93nviuYiriCQ829f7ypx3aScYDR1YoQ",
+    validatorVoteAccount: "D3QPJm7BDzzPeRG51YZSEz3LfV7GvFNu9NkcibzURxuj",
+    tokenAddress: "8hXCCQmYFcDhU5Mkuvyixp2Q11sbyQComkceSSh3GY4a",
+    tokenName: "Starke Finance",
+    tokenSymbol: "STARKE"
+  },
+  {
+    bankAddress: "37tiA2NTF6YCt85XzCidPo9ZVpuqkkmfVJCYQ5Yx5Uhs",
+    validatorVoteAccount: "SBLZib4npE7svxFA7AsD3ytdQAfYNb39c8zsU82AA2E",
+    tokenAddress: "96rXgCFy1Er49169XoKHkeLiKC2k4bTy1641q1TVrMm2",
+    tokenName: "SolBlaze Validator",
+    tokenSymbol: "SOLBLAZE"
+  },
+  {
+    bankAddress: "J9trpcrVdFjVNg6VFrdF1XPGgjftQKZhbbWsxertdv9V",
+    validatorVoteAccount: "FACqsS19VScz8oo2YhdMg35EsAy6xsCZ9Y58eJXGv8QJ",
+    tokenAddress: "AH6fxpHS2gtMtJgBy8y8pEAPkqyop2pSugF6REs9NaTp",
+    tokenName: "Lantern",
+    tokenSymbol: "LNTRN"
+  },
+  {
+    bankAddress: "EGTfrYiuWpPPZ4yfY9tCxnK6QMkY7pzVie9DxK772iGe",
+    validatorVoteAccount: "EfnywDKqArxK6N6FS9ctsuzNdxfx3pzfXEQE5EevQ1SV",
+    tokenAddress: "FcXEwHku68ZquqtSj1eSWS1SVWkhAZSyb4usfpiuEJAL",
+    tokenName: "PROJECT SUPER",
+    tokenSymbol: "SUPER"
+  },
+  {
+    bankAddress: "A5e7UTE3g11ZfKgftqRCvxAgcDuFGyeDjMka96zJWSWe",
+    validatorVoteAccount: "3ZUQekqiZoybB57y49eqtvSaoonqDwuNbeqEGwN88JkQ",
+    tokenAddress: "F1XPjtpsEy23Q7po4JkWjp1jkDZcvFYSrqD8TR1YL3EF",
+    tokenName: "Paws",
+    tokenSymbol: "PAWS"
+  },
+  {
+    bankAddress: "91jkdp4cF8vCDhjwude3SGSGrmVWFk5vTAtR6fsGVAfy",
+    validatorVoteAccount: "gangtRyGPTvYWb8K3xS2feJQaCks4iJ7rytFUPtVqSY",
+    tokenAddress: "6ZS7ZVDw91BVAC8gsz3SZBSeVeF2GtXtL2BHK31Kvyjm",
+    tokenName: "Lotus Validator",
+    tokenSymbol: "LOTUS"
+  },
+  {
+    bankAddress: "72BS34HkCgq8RWQR7kuVVmiJMtKqSxG4CHX6ZXpSCwg7",
+    validatorVoteAccount: "oRAnGeU5h8h2UkvbfnE5cjXnnAa4rBoaxmS4kbFymSe",
+    tokenAddress: "9yF8pXctzicum2P73uuk4Dhqf2MVz6tzRAe8THGXCJcp",
+    tokenName: "Orangefin Ventures",
+    tokenSymbol: "ORANGEFIN"
+  },
+  {
+    bankAddress: "8F4DsU3NMFunUxBZkWrpYR8zwhAfoAt7QuiEPMtyhWvX",
+    validatorVoteAccount: "3xjfK9C9YNcta8MvK1US4sQ3bc6DEjoJoR3qLExGf9xE",
+    tokenAddress: "Akib1NYJzzh9HkiDH41S2LUefUmR1bKsk65xgqUcW5C5",
+    tokenName: "pico\u{1F644}.sol",
+    tokenSymbol: "PICO"
+  },
+  {
+    bankAddress: "GdtggomQth6cxuYPdiVhBbcX7VC9rnDDwLMfxipxE2Po",
+    validatorVoteAccount: "oPaLTmyvoUhW26QCMwLA5JNUeBYy72PDpFoXQF8SeX4",
+    tokenAddress: "C71A3W7g5XALUNwTDWTwHX3qhfypaYZ41aNZjBpcaC9D",
+    tokenName: "Temporal Opal",
+    tokenSymbol: "OPAL"
+  },
+  {
+    bankAddress: "5sJCKePwAhyD3mzrzLRDM2PkFMc85nnvvarxHLsvWvpg",
+    validatorVoteAccount: "9jYFwBfbjYmvasFbJyES9apLJDTkwtbgSDRWanHEvcRw",
+    tokenAddress: "Hj69K1WbnfZFipLbrzdxgGhDqCR47q48bN5nUHt6xQZo",
+    tokenName: "WATCHTOWER",
+    tokenSymbol: "WATCHTOWER"
+  },
+  {
+    bankAddress: "3F3QXT3BtkegaBfFjn2odKLurFYLHJHJ99xKV2TRTvrk",
+    validatorVoteAccount: "6JfBwvcz5QUKQJ37BMKTLrf968DDJBtwoZLw19aHwFtQ",
+    tokenAddress: "8FqX86cQofBHReetZgxrxxvzN4iqMVsj2hbiv7pj2h73",
+    tokenName: "Spectrum Staking",
+    tokenSymbol: "SPECTRUM"
+  },
+  {
+    bankAddress: "CFmvdtEPQJPVqS1QRkeRcdQm2itAPk6k8hSJbmt88Sjc",
+    validatorVoteAccount: "Haz7b47sZBpxh9SwggGndN3fAyNQ1S949BPdxWXS3ab6",
+    tokenAddress: "38ZUTefZnKSUJU3wxpUe3xpiw2j5WQPnmzSTNbS1JqLA",
+    tokenName: "Temporal Emerald",
+    tokenSymbol: "EMERALD"
+  },
+  {
+    bankAddress: "CmBDHSVuodmUnanbBVFvY9cauLeosbdFQn9bJANMVYUG",
+    validatorVoteAccount: "mintrNtxN3PhAB45Pt41XqyKghTTpqcoBkQTZqh96iR",
+    tokenAddress: "GxGmv7s7s2co3pLZukns946fr5zmR8c5buWRD9prGd6v",
+    tokenName: "Hanabi Staking",
+    tokenSymbol: "haSOLmrgn"
+  },
+  {
+    bankAddress: "7bLfrb4fWVYkVpZ9rg7dBUwKRAqLyiivCW4ahMMGcKyS",
+    validatorVoteAccount: "76DafWkJ6pGK2hoD41HjrM4xTBhfKqrDYDazv13n5ir1",
+    tokenAddress: "GT7n9uZbYzHv52YqDBowtZ5ZVW91umaBQTNPFQNeLUpR",
+    tokenName: "Solana Japan Validator",
+    tokenSymbol: "SolJAPAn"
+  },
+  {
+    bankAddress: "6q5DB86DhCBQt5bqzZwgopV8EA96aCnngu5ebR1ooDFq",
+    validatorVoteAccount: "Cue647T8jgwpRSDUb8ttTYx7NiEfJCRZNiiw1qmchXsG",
+    tokenAddress: "EAR6LenhNstHxR9289rWakm82WgLJYvHD7NawfXtuyUx",
+    tokenName: "KIWAMI",
+    tokenSymbol: "KIWAMI"
+  },
+  {
+    bankAddress: "GLSCJ39N82Xo21621jMheinvjQLrBrkG7gzo2C5L1y6y",
+    validatorVoteAccount: "7emL18Bnve7wbYE9Az7vYJjikxN6YPU81igf6rVU5FN8",
+    tokenAddress: "EQuMUgLZArKwWUk6uGPmTGYUgNbfgJrbBaNR7CQyZ5uf",
+    tokenName: "Temporal Topaz",
+    tokenSymbol: "TOPAZ"
+  },
+  {
+    bankAddress: "4irzCCsU53ffh9XB7NxGzbbHjvSR7FTfPbn6KoXkt7kX",
+    validatorVoteAccount: "2iWXwF2Q5W6o7yntV2mkbxncB4rYHnX61y3NU8a8EFMJ",
+    tokenAddress: "14Pets6QpE9iXKkXg8Ri4GcDazRMfWR3guM6LZXnFChc",
+    tokenName: "Bull Moose SOL",
+    tokenSymbol: "bmsSOL"
+  },
+  {
+    bankAddress: "C96do7nkEaaFjHq8jHzPpyPTdJSea5xEGwxDzDSepCzf",
+    validatorVoteAccount: "voteRnv6PBzmiGP8NicWtQiqEJTwKKq2SxtqtdLUJjd",
+    tokenAddress: "3YEDiJ4r4xRGNhq6nudRnkwrdKHG7PAtDim24CjTMtBH",
+    tokenName: "diman",
+    tokenSymbol: "DIMAN"
+  },
+  {
+    bankAddress: "9dZiyG51FBR4BWpAs69XbDpr7GfVAEB1ZB89v38maV36",
+    validatorVoteAccount: "Simpj3KyRQmpRkXuBvCQFS7DBBG6vqw93SkZb9UD1hp",
+    tokenAddress: "77YLpVLQXr2KU66GM2JykbT9g5du7LarWgehbWD3CJaB",
+    tokenName: "SIMPDIGIT",
+    tokenSymbol: "SIMPDIGIT"
+  },
+  {
+    bankAddress: "2foqT8wWzWRduyV37uRdj81DijkNMKzYD3D6JPfir7La",
+    validatorVoteAccount: "48oxpSHQkM4sdXUY9NQ8KnEtebzZbyk8uUT7JRdVQNuf",
+    tokenAddress: "42m7Ygk5VxREdKfcFrsH1HnuoqCke8BcVcxNeywMCfp2",
+    tokenName: "Infinite Lux",
+    tokenSymbol: "LUX"
+  },
+  {
+    bankAddress: "FsdWEJzHXkUXejWnb7c1p9UJtF69hVWQNNoakjoXyRCJ",
+    validatorVoteAccount: "4AUED4uj6nSTuANzaAUnGBPJQRmhpDYDwoWJNkoUUBBW",
+    tokenAddress: "CiyQTfHJ9PbTwC7TGf4pXZk8szcWGJ8TeFhhCuUwybqi",
+    tokenName: "Anagram",
+    tokenSymbol: "ANAGRAM"
+  },
+  {
+    bankAddress: "2hs1pHAzDWGqnn1d8VQkc8bZRfQ45grYvzfau8dnWFUk",
+    validatorVoteAccount: "2NxEEbhqqj1Qptq5LXLbDTP5tLa9f7PqkU8zNgxbGU9P",
+    tokenAddress: "9yQLxEzusZ7QiZNafDNdzbEaTCPuJToGjMhLRJtZbgsd",
+    tokenName: "NANSEN",
+    tokenSymbol: "NANSEN"
+  },
+  {
+    bankAddress: "FCi8unSVCwJd3QkrhTtv6LTTjw1c4zV65D5cG5N1rAG6",
+    validatorVoteAccount: "Va1idkzkB6LEmVFmxWbWU8Ao9qehC62Tjmf68L3uYKj",
+    tokenAddress: "AExKb8oJ6mGPYJUyfiX49DMMi226h2AnWeG1G6neQBEz",
+    tokenName: "VALIDATOR",
+    tokenSymbol: "VALID"
+  },
+  {
+    bankAddress: "HzS8RqaQ5syk6EHbVi7h9rFYN48PpxykUXEs6w9wNfNP",
+    validatorVoteAccount: "sTach38ebT8jnGH8i2D1g8NDAS6An19whVMnSSWPXt4",
+    tokenAddress: "AFDVYBqxADagPfN9DdbrNrf9zZqugub7CV4kUJEUrK6J",
+    tokenName: "Stache Node",
+    tokenSymbol: "STACHE"
+  },
+  {
+    bankAddress: "9Hs4E6ACNw6Hmwjvm1duXzbaWmvXxSxN11agw4updEn1",
+    validatorVoteAccount: "EtMSc3MvcDXUr6ChK5GxyFVwTxYA3zqP5XzjE9jwKvSV",
+    tokenAddress: "ENKFyZQZHzNNSxcKYoaVsNLi2xoGPoStZH4A9xxezjbC",
+    tokenName: "Mad Lads CN",
+    tokenSymbol: "MadLadsCN"
+  },
+  {
+    bankAddress: "4watsWcjTBAwsrZpArwQbnNX4bQ1yeHBxgdbrGT4eMu9",
+    validatorVoteAccount: "EARNynHRWg6GfyJCmrrizcZxARB3HVzcaasvNa8kBS72",
+    tokenAddress: "8fhkWcm2n28JuadzY7mRR8FFDZZfnaPfWgw7pLNVZCbE",
+    tokenName: "Solana Compass Stake",
+    tokenSymbol: "compaStake"
+  },
+  {
+    bankAddress: "9d7MTvcz1VMB1rK6H73quMxkR26dLPz5HDaac2eGRjQx",
+    validatorVoteAccount: "nymsndUdAZyUPpWYz5VEg8Ghj9cFvwTRgciLogpmYaQ",
+    tokenAddress: "FWFeaqpkgDr3ejVSY3HjiUmUg3u9fcr5d66HvimnDLWE",
+    tokenName: "Hypo Nyms",
+    tokenSymbol: "NYMS"
+  },
+  {
+    bankAddress: "6V4vCK3n3JVncfpS16mW8ceLoNPatvu61pKxFmWx8adi",
+    validatorVoteAccount: "BT8LZUvQVwFHRGw2Dwv7UeqDUq7btfjegLpuz5bwgziD",
+    tokenAddress: "9YRS7Stf9dVibTT1M4uVEAuRMcoS4MH1QxqXy9Lssrab",
+    tokenName: "private",
+    tokenSymbol: "private"
+  },
+  {
+    bankAddress: "CK8qRAcmvkDXaqX2S5GkgTCZT5pCz34me1neQhpJYe1Z",
+    validatorVoteAccount: "Ac1beBKixfNdrTAac7GRaTsJTxLyvgGvJjvy4qQfvyfc",
+    tokenAddress: "DLTAbTL5NXhbqX6LX3ie3tf52pdtGpxe2DrZUr1RhgY6",
+    tokenName: "Stronghold",
+    tokenSymbol: "Stronghold"
+  },
+  {
+    bankAddress: "H6CT1aiCgSNw9S6aq38npEhdoN2UPhSKe8Lj9fQqqjuu",
+    validatorVoteAccount: "FREEL1BCzmPpNneC7FHCtBqzeWYrHRbtisFvi4N8XUP9",
+    tokenAddress: "AKFuMoM5rjSpQSL4p6TBoc7D4dmEem9QrHhuSDCBYyZ8",
+    tokenName: "Ross",
+    tokenSymbol: "Ross"
+  },
+  {
+    bankAddress: "G46aHuakgStymbE2WsLbja61mH5UXBPdSdpwf6Ci3saG",
+    validatorVoteAccount: "mnvkHm47ZmRKoSWuQZAfXLRiDPiKCq8PWkMWrp1Wwqe",
+    tokenAddress: "Cq9S5UB9BviPn5yoGkEDk3m7neQag4KJnhPWGyuev9W8",
+    tokenName: "gripto staked sol",
+    tokenSymbol: "GRIPTO"
+  },
+  {
+    bankAddress: "75UmeEMdqVnGn3JHx8yVZEn7viybJ73XYSjhYCYfyhp2",
+    validatorVoteAccount: "4m1PbxzwLdUnEwog3T9UKxgjktgriHgE1CfAhMqDw7Xx",
+    tokenAddress: "432SogPNunjZMneDV6goZ8ZcCQz282GxoSJ4rwqx95pT",
+    tokenName: "kumasol",
+    tokenSymbol: "kumasol"
+  },
+  {
+    bankAddress: "3zk6EmXANYQK12bwy9dySRAM4cT2vT5cDcAB79j8G33B",
+    validatorVoteAccount: "HvsD9L5t62MGv3QBD2K7xjkipGYr9UZN7BtsW8NuSPpg",
+    tokenAddress: "5vmwd6JHDCmX9W2XT1n2QpvYGA2kk4Xf7qWSayDU6caT",
+    tokenName: "ArgenTerraSOL",
+    tokenSymbol: "atSOL"
+  },
+  {
+    bankAddress: "4C2vPweGNpiE6kTEbYvcbUBHNWxrn4ErQYaqWm5zDexx",
+    validatorVoteAccount: "FnAPJkzf19s87sm24Qhv6bHZMZvZ43gjNUBRgjwXpD4v",
+    tokenAddress: "6q4kVnwUpkE3i7W32dqaX6V12pbsrCnMqZ7TWz9yp1m5",
+    tokenName: "BLOCKPORT",
+    tokenSymbol: "BPT"
+  },
+  {
+    bankAddress: "E5hZu5QQ1pRmGvyS4JHGXVQwzdUPaYM4yEiNKr64YzyG",
+    validatorVoteAccount: "nfGcSJkP35SkPa5475iBChmq1UNcj7JE1uQHrrasymm",
+    tokenAddress: "AQpQoJ3tJKGH9Yn8GSzoUsVcHPJjj3xYfQFp9XVr74F6",
+    tokenName: "Test01",
+    tokenSymbol: "TEST01"
+  },
+  {
+    bankAddress: "3VCkXWAmE5DSwYRpqGFnkUz7vvD2RKbhFvrhzLuE8msu",
+    validatorVoteAccount: "abc1zP7ihWsgQW8z5YmfQNqMckJE5Dfx8fwUNMNVNkY",
+    tokenAddress: "BNisp3omkr6Rg5nHESWafjUbeCpGPy6MYq1iRJRgSAsh",
+    tokenName: "ALGO STAKE",
+    tokenSymbol: "ALGO"
+  },
+  {
+    bankAddress: "7BHHMWw3P1AyebLhX9A8wnDeeGy8jgFXqqHuEZt7BVmW",
+    validatorVoteAccount: "8Pep3GmYiijRALqrMKpez92cxvF4YPTzoZg83uXh14pW",
+    tokenAddress: "zBH13AzXYCqHZKS8NGa4KR8zQhWiyvFdDY15nmfrHgS",
+    tokenName: "8Pep",
+    tokenSymbol: "8Pep"
+  },
+  {
+    bankAddress: "9QWUatjtJtc98yts4ufWnmNeaWQRmaaLjFwbK3iMdS47",
+    validatorVoteAccount: "CatzoSMUkTRidT5DwBxAC2pEtnwMBTpkCepHkFgZDiqb",
+    tokenAddress: "98B1NMLYaNJQNxiQGr53vbjNFMNTYFmDqoCgj7qD9Vhm",
+    tokenName: "JUPITER ",
+    tokenSymbol: "JUPITER"
+  },
+  {
+    bankAddress: "5q1wJkGqqRh6mSBtjG8sfjBsgJSGdA2QoXTWv4UQbHGk",
+    validatorVoteAccount: "shft7Fry1js37Hm9wq4dfwcZSp2DyKszeWMvEpjYCQ1",
+    tokenAddress: "C1KwBJZNwUaodUcP5kXqD52NCuZzThNAG2cw3vt5H6iE",
+    tokenName: "BLUESHIFT",
+    tokenSymbol: "SHIFT"
+  },
+  {
+    bankAddress: "FZaHyfg9hmNMKpfUJ474wNKPaPdXMpnJouasKnndECiZ",
+    validatorVoteAccount: "DdCNGDpP7qMgoAy6paFzhhak2EeyCZcgjH7ak5u5v28m",
+    tokenAddress: "PhxXAYTkFZS23ZWvFcz6H6Uq4VnVBMa6hniiAyudjaW",
+    tokenName: "KILN1",
+    tokenSymbol: "KILN1"
+  },
+  {
+    bankAddress: "5CBocarwfJeWGNozGemWktRYSz6kPikRPdfH8ZHSFrsg",
+    validatorVoteAccount: "8zuMRTXThoPTTPLLvaiKiJshLLCqGMt9BdRjjCL19xBc",
+    tokenAddress: "BDsEuxFWznAP5cUCannnfjyjDtTwqN57CkGfDbjx2nNZ",
+    tokenName: "DawnLabs",
+    tokenSymbol: "DawnLabs"
+  },
+  {
+    bankAddress: "9ivswG37QpCUmkPkLMpRZT7PMyP64V9dDpZdteM254ec",
+    validatorVoteAccount: "gaToR246dheK1DGAMEqxMdBJZwU4qFyt7DzhSwAHFWF",
+    tokenAddress: "TjA2rtxoUFzyPVAw35VQGEQnNXiwcmNjKSk29nmkq1P",
+    tokenName: "Valigator Open",
+    tokenSymbol: "Valigator"
+  }
+];
+
+// src/services/native-stake/utils/metadata.utils.ts
+var _metadataMap = null;
+var _voteAccountByBank = null;
+function getStakedBankMetadataMap() {
+  if (!_metadataMap) {
+    _metadataMap = /* @__PURE__ */ new Map();
+    for (const entry of STAKED_BANK_METADATA_JSON) {
+      _metadataMap.set(entry.bankAddress, entry);
+    }
+  }
+  return _metadataMap;
+}
+function getValidatorVoteAccountByBank() {
+  if (!_voteAccountByBank) {
+    _voteAccountByBank = {};
+    for (const entry of STAKED_BANK_METADATA_JSON) {
+      _voteAccountByBank[entry.bankAddress] = entry.validatorVoteAccount;
+    }
+  }
+  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;
@@ -54538,7 +55440,6 @@ var Project0Client = class _Project0Client {
           assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
           break;
         case 2 /* STAKED */:
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
           break;
         case 0 /* DEFAULT */:
         case 1 /* SOL */:
@@ -54547,6 +55448,11 @@ var Project0Client = class _Project0Client {
           break;
       }
     });
+    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,
@@ -54588,6 +55494,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, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, 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, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, 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