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

package/dist/index.cjs

@@ -118,10 +118,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";
@@ -142,23 +141,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 */,
@@ -173,6 +155,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
    */
@@ -15163,9 +15152,48 @@ var MintLayout = bufferLayout.struct([
   bufferLayoutUtils.publicKey("freezeAuthority")
 ]);
 MintLayout.span;
+var approveInstructionData = bufferLayout.struct([
+  bufferLayout.u8("instruction"),
+  bufferLayoutUtils.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.Buffer.alloc(approveInstructionData.span);
+  approveInstructionData.encode(
+    {
+      instruction: 4 /* Approve */,
+      amount: BigInt(amount)
+    },
+    data
+  );
+  return new web3_js.TransactionInstruction({ keys, programId, data });
+}
 bufferLayout.struct([
   bufferLayout.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: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false },
+    { pubkey: web3_js.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: associatedTokenProgramId,
+    data: buffer.Buffer.alloc(0)
+  });
+}
 function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
   return buildAssociatedTokenAccountInstruction(
     payer,
@@ -43378,6 +43406,173 @@ new Fraction(new BN11__default.default(0));
 function roundNearest(decimal) {
   return decimal.toDecimalPlaces(0, Decimal3__default.default.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: web3_js.STAKE_CONFIG_ID, 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 BN11.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] = web3_js.PublicKey.findProgramAddressSync(
     [Buffer.from(prefix), baseAddress.toBuffer()],
@@ -43388,7 +43583,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] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("metadata"), MPL_METADATA_PROGRAM_ID.toBuffer(), poolMintAddress.toBuffer()],
+    MPL_METADATA_PROGRAM_ID
+  );
+  return pda;
+};
 BigInt(33);
 BigInt(200);
 BigInt(82);
@@ -44169,12 +44374,28 @@ var V1Client = class _V1Client {
     return new Promise((resolve, reject) => {
       const ws = new WebSocket__default.default(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 ---
@@ -46175,10 +46396,11 @@ async function makeBorrowIx3({
     );
     borrowIxs.push(createAtaIdempotentIx);
   }
+  const mandatoryBanks = [bank.address, ...opts.additionalHealthCheckBanks ?? []];
   const healthAccounts = computeHealthCheckAccounts(
     marginfiAccount.balances,
     bankMap,
-    [bank.address],
+    mandatoryBanks,
     []
   );
   const remainingAccounts = [];
@@ -46713,81 +46935,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 BigNumber3.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__default.default(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__default.default(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 web3_js.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 web3_js.TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: blockhash,
+    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
+  }).compileToV0Message(addressLookupTableAccounts);
+  const tx = addTransactionMetadata(new web3_js.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({
@@ -46795,34 +47052,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
   });
@@ -46832,7 +47089,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;
       }
     }
@@ -46844,18 +47101,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 BigNumber3.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,
@@ -46885,16 +47148,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,
@@ -46905,20 +47171,20 @@ async function buildRepayWithCollatFlashloanTx({
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.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 web3_js.PublicKey(repayOpts.repayBank.mint),
+      new web3_js.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,
@@ -46927,24 +47193,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,
@@ -46954,50 +47217,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 BigNumber3.BigNumber(1);
-      const adjustedAmount = new BigNumber3.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
         }
@@ -47005,35 +47270,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
         }
@@ -47041,33 +47298,15 @@ 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({
+      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,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
+        group: marginfiAccount.group,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47075,645 +47314,140 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     default: {
-      withdrawIxs = await makeWithdrawIx3({
-        program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
-        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__default.default(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 web3_js.TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: web3_js.PublicKey.default.toBase58(),
-    instructions: allNonSwapIxs
-  }).compileToV0Message(addressLookupTableAccounts);
-  const nonSwapSize = new web3_js.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 web3_js.TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: web3_js.PublicKey.default.toBase58(),
-    instructions: allIxs
-  }).compileToV0Message(luts);
-  const rawSize = new web3_js.VersionedTransaction(msg).serialize().length;
-  const fullTxSize = rawSize + FL_IX_OVERHEAD;
-  const overshoot = fullTxSize - MAX_TX_SIZE;
-  const { header, staticAccountKeys, addressTableLookups } = msg;
-  const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
-  const writableLut = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
-  const writableAccounts = writableStatic + writableLut;
-  const totalAccounts = staticAccountKeys.length + addressTableLookups.reduce(
-    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
-    0
-  );
-  console.log("[flashloan-precheck]", {
-    fullTxSize,
-    overshoot,
-    sizeConstraint,
-    writableAccounts,
-    totalAccounts,
-    staticKeys: staticAccountKeys.length,
-    numLuts: addressTableLookups.length,
-    swapIxCount,
-    swapLutCount
-  });
-  return { fullTxSize, overshoot, writableAccounts, totalAccounts };
-}
-async function buildBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  switch (config.type) {
-    case "borrow":
-      return makeBorrowIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        isSync: true,
-        opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
-      });
-    case "repay":
-      return makeRepayIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        repayAll: false,
-        isSync: true,
-        opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
-      });
-    case "deposit":
-      return buildDepositBudgetIx(
-        config,
-        program,
-        marginfiAccount,
-        bankMetadataMap,
-        overrideInferAccounts
-      );
-    case "withdraw":
-      return buildWithdrawBudgetIx(
-        config,
-        program,
-        marginfiAccount,
-        bankMap,
-        bankMetadataMap,
-        overrideInferAccounts
-      );
-  }
-}
-async function buildDepositBudgetIx(config, program, marginfiAccount, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  const opts = { wrapAndUnwrapSol: false, overrideInferAccounts };
-  switch (bank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeKaminoDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        reserve,
-        isSync: true,
-        opts
-      });
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeDriftDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex: driftState.spotMarketState.marketIndex,
-        driftOracle: driftState.spotMarketState.oracle,
-        isSync: true,
-        opts
-      });
-    }
-    case 6 /* JUPLEND */: {
-      return makeJuplendDepositIx2({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        isSync: true,
-        opts
-      });
-    }
-    default: {
-      return makeDepositIx3({
-        program,
-        bank,
-        tokenProgram,
-        amount: 1,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        isSync: true,
-        opts
-      });
-    }
-  }
-}
-async function buildWithdrawBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
-  const { bank, tokenProgram } = config;
-  const opts = { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts };
-  switch (bank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeKaminoWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        cTokenAmount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        reserve,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeDriftWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        driftSpotMarket: driftState.spotMarketState,
-        userRewards: driftState.userRewards,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-    case 6 /* JUPLEND */: {
-      const jupLendState = bankMetadataMap[bank.address.toBase58()]?.jupLendStates;
-      if (!jupLendState) {
-        throw TransactionBuildingError.jupLendStateNotFound(
-          bank.address.toBase58(),
-          bank.mint.toBase58(),
-          bank.tokenSymbol
-        );
-      }
-      return makeJuplendWithdrawIx2({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: false,
-        opts
-      });
-    }
-    default: {
-      return makeWithdrawIx3({
-        program,
-        bank,
-        bankMap,
-        tokenProgram,
-        amount: 1,
-        marginfiAccount,
+      depositIxs = await makeDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         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 = [
-    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    web3_js.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__default.default(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 BigNumber3.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__default.default(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 web3_js.TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: blockhash,
-    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
-  }).compileToV0Message(addressLookupTableAccounts);
-  const tx = addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-    addressLookupTables: addressLookupTableAccounts,
-    type: "FLASHLOAN" /* FLASHLOAN */,
-    signers
+async function makeRepayTx(params) {
+  const { luts, ...depositIxParams } = params;
+  const ixs = await makeRepayIx3(depositIxParams);
+  const tx = new web3_js.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({
@@ -47721,34 +47455,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
   });
@@ -47758,7 +47492,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;
       }
     }
@@ -47770,24 +47504,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 BigNumber3.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,
@@ -47817,19 +47545,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,
@@ -47840,20 +47565,20 @@ async function buildLoopFlashloanTx({
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.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 web3_js.PublicKey(depositOpts.depositBank.mint),
+      new web3_js.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,
@@ -47862,21 +47587,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,
@@ -47886,52 +47614,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 BigNumber3.BigNumber(1);
+      const adjustedAmount = new BigNumber3.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
         }
@@ -47939,27 +47665,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
         }
@@ -47967,15 +47701,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
         }
@@ -47983,15 +47735,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
         }
@@ -47999,12 +47761,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({
@@ -48022,12 +47805,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
@@ -48037,9 +47821,9 @@ async function buildLoopFlashloanTx({
     flashloanTx,
     setupInstructions,
     swapQuote,
-    borrowIxs,
-    depositIxs,
-    amountToDeposit
+    withdrawIxs,
+    repayIxs,
+    amountToRepay
   };
 }
 
@@ -48470,7 +48254,7 @@ async function buildSwapCollateralFlashloanTx({
   const txSize = getTxSize(flashloanTx);
   const totalKeys = getTotalAccountKeys(flashloanTx);
   if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
       txSize,
       totalKeys,
       swapOpts.swapConfig?.provider
@@ -48731,7 +48515,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
@@ -49401,23 +49185,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
     );
   }
 };
@@ -49593,7 +49381,7 @@ async function getTitanExactOutViaWebSocket(params) {
         inputMint: new web3_js.PublicKey(inputMint).toBytes(),
         outputMint: new web3_js.PublicKey(outputMint).toBytes(),
         amount,
-        swapMode: "ExactOut",
+        swapMode: "ExactOut" /* ExactOut */,
         slippageBps
       },
       transaction: {
@@ -49813,178 +49601,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 web3_js.PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
+var REFERRAL_ACCOUNT_PUBKEY = new web3_js.PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
+var getFeeAccount = (mint) => {
+  const [feeAccount] = web3_js.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 web3_js.PublicKey(feeAccount));
+  return { feeAccount, hasFeeAccount };
+};
+function deserializeJupiterInstruction(instruction) {
+  return new web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(instruction.programId),
+    keys: instruction.accounts.map((key) => ({
+      pubkey: new web3_js.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 api.SwapApi(new api.Configuration(configParams)) : api.createJupiterApiClient(configParams);
+  const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
+  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new web3_js.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 web3_js.PublicKey(address))
+  );
+  const addressLookupTableAccounts = lutAccountsRaw.map((accountInfo, index) => {
+    const addressLookupTableAddress = lutAddresses[index];
+    if (!accountInfo || !addressLookupTableAddress) {
+      return null;
+    }
+    return new web3_js.AddressLookupTableAccount({
+      key: new web3_js.PublicKey(addressLookupTableAddress),
+      state: web3_js.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__default.default(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 web3_js.TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: web3_js.PublicKey.default.toBase58(),
+    instructions: allNonSwapIxs
+  }).compileToV0Message(addressLookupTableAccounts);
+  const nonSwapSize = new web3_js.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 web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: web3_js.PublicKey.default.toBase58(),
+    instructions: allIxs
+  }).compileToV0Message(luts);
+  const rawSize = new web3_js.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 web3_js.PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
-var REFERRAL_ACCOUNT_PUBKEY = new web3_js.PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
-var getFeeAccount = (mint) => {
-  const [feeAccount] = web3_js.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 web3_js.PublicKey(feeAccount));
-  return { feeAccount, hasFeeAccount };
-};
-function deserializeJupiterInstruction(instruction) {
-  return new web3_js.TransactionInstruction({
-    programId: new web3_js.PublicKey(instruction.programId),
-    keys: instruction.accounts.map((key) => ({
-      pubkey: new web3_js.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 api.SwapApi(new api.Configuration(configParams)) : api.createJupiterApiClient(configParams);
-  const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
-  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new web3_js.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 web3_js.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 web3_js.AddressLookupTableAccount({
-      key: new web3_js.PublicKey(addressLookupTableAddress),
-      state: web3_js.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 = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.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
@@ -50652,18 +50878,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;
@@ -51467,6 +51690,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;
@@ -51868,6 +52163,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__default.default(1));
+      continue;
+    }
+    const pool = findPoolAddress(new web3_js.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__default.default(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__default.default(1));
+      continue;
+    }
+    const adjustedStake = Math.max(stakeLamports - web3_js.LAMPORTS_PER_SOL, 0);
+    const multiplier = new BigNumber3__default.default(adjustedStake).dividedBy(lstMintSupply);
+    multiplierByBank.set(bankAddr, multiplier);
+  }
+  return multiplierByBank;
+}
+var SYSVAR_CLOCK_ID2 = new web3_js.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(web3_js.StakeProgram.space)
+  ]);
+  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
+  const amountLamports = Math.round(Number(amount) * web3_js.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 = web3_js.Keypair.generate();
+    signers.push(splitStakeAccount);
+    targetStakePubkey = splitStakeAccount.publicKey;
+    instructions2.push(
+      ...web3_js.StakeProgram.split(
+        {
+          stakePubkey: stakeAccountPk,
+          authorizedPubkey: authority,
+          splitStakePubkey: splitStakeAccount.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      ).instructions
+    );
+  } else {
+    targetStakePubkey = stakeAccountPk;
+  }
+  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
+    web3_js.StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: web3_js.StakeAuthorizationLayout.Staker
+    }).instructions,
+    web3_js.StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: web3_js.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 web3_js.TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.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(
+    web3_js.StakeProgram.space
+  );
+  const stakeAmount = new BigNumber3__default.default(new BigNumber3__default.default(amount).toString());
+  const instructions2 = [];
+  const signers = [];
+  const stakeAccount = web3_js.Keypair.generate();
+  signers.push(stakeAccount);
+  instructions2.push(
+    web3_js.SystemProgram.createAccount({
+      fromPubkey: authority,
+      newAccountPubkey: stakeAccount.publicKey,
+      lamports: rentExemption,
+      space: web3_js.StakeProgram.space,
+      programId: web3_js.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 web3_js.TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.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 = web3_js.StakeProgram.merge({
+    stakePubkey: destinationStakeAccount,
+    sourceStakePubKey: sourceStakeAccount,
+    authorizedPubkey: authority
+  }).instructions;
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: authority,
+    recentBlockhash: blockhash,
+    instructions: mergeIx
+  }).compileToV0Message(luts);
+  const tx = new web3_js.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 = web3_js.PublicKey.default;
@@ -54565,7 +55467,6 @@ var Project0Client = class _Project0Client {
           assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__default.default(1));
           break;
         case 2 /* STAKED */:
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__default.default(1));
           break;
         case 0 /* DEFAULT */:
         case 1 /* SOL */:
@@ -54574,6 +55475,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,
@@ -54725,6 +55631,16 @@ exports.computeActiveEmodePairs = computeActiveEmodePairs;
 exports.computeAssetHealthComponent = computeAssetHealthComponent;
 exports.computeAssetUsdValue = computeAssetUsdValue;
 exports.computeBalanceUsdValue = computeBalanceUsdValue;
+exports.computeBankBorrowApy = computeBankBorrowApy;
+exports.computeBankBorrowCapRemaining = computeBankBorrowCapRemaining;
+exports.computeBankDepositCapRemaining = computeBankDepositCapRemaining;
+exports.computeBankMetrics = computeBankMetrics;
+exports.computeBankPoolSize = computeBankPoolSize;
+exports.computeBankSupplyApy = computeBankSupplyApy;
+exports.computeBankTotalBorrows = computeBankTotalBorrows;
+exports.computeBankTotalBorrowsUsd = computeBankTotalBorrowsUsd;
+exports.computeBankTotalDeposits = computeBankTotalDeposits;
+exports.computeBankTotalDepositsUsd = computeBankTotalDepositsUsd;
 exports.computeBaseInterestRate = computeBaseInterestRate;
 exports.computeClaimedEmissions = computeClaimedEmissions;
 exports.computeClosePositionTokenAmount = computeClosePositionTokenAmount;
@@ -54755,6 +55671,7 @@ exports.computeQuantity = computeQuantity;
 exports.computeQuantityUi = computeQuantityUi;
 exports.computeRemainingCapacity = computeRemainingCapacity;
 exports.computeSmartCrank = computeSmartCrank;
+exports.computeStakedBankMultipliers = computeStakedBankMultipliers;
 exports.computeTotalOutstandingEmissions = computeTotalOutstandingEmissions;
 exports.computeTvl = computeTvl;
 exports.computeUsdValue = computeUsdValue;
@@ -54815,6 +55732,7 @@ exports.fetchSwbOraclePricesFromAPI = fetchSwbOraclePricesFromAPI;
 exports.fetchSwbOraclePricesFromCrossbar = fetchSwbOraclePricesFromCrossbar;
 exports.findRandomAvailableAccountIndex = findRandomAvailableAccountIndex;
 exports.freezeBankConfigIx = freezeBankConfigIx;
+exports.generateDummyAccount = generateDummyAccount;
 exports.getAccountKeys = getAccountKeys;
 exports.getActiveAccountFlags = getActiveAccountFlags;
 exports.getActiveBalances = getActiveBalances;
@@ -54853,6 +55771,7 @@ exports.getOracleSourceFromOracleSetup = getOracleSourceFromOracleSetup;
 exports.getOracleSourceNameFromKey = getOracleSourceNameFromKey;
 exports.getPrice = getPrice;
 exports.getPriceWithConfidence = getPriceWithConfidence;
+exports.getStakedBankMetadataMap = getStakedBankMetadataMap;
 exports.getSwapIxsForFlashloan = getSwapIxsForFlashloan;
 exports.getTitanExactOutEstimate = getTitanExactOutEstimate;
 exports.getTitanSwapIxsForFlashloan = getTitanSwapIxsForFlashloan;
@@ -54860,6 +55779,7 @@ exports.getTotalAccountKeys = getTotalAccountKeys;
 exports.getTotalAssetQuantity = getTotalAssetQuantity;
 exports.getTotalLiabilityQuantity = getTotalLiabilityQuantity;
 exports.getTxSize = getTxSize;
+exports.getValidatorVoteAccountByBank = getValidatorVoteAccountByBank;
 exports.getWritableAccountKeys = getWritableAccountKeys;
 exports.groupToDto = groupToDto;
 exports.hasAccountFlag = hasAccountFlag;
@@ -54901,11 +55821,16 @@ exports.makeKaminoDepositTx = makeKaminoDepositTx;
 exports.makeKaminoWithdrawIx = makeKaminoWithdrawIx3;
 exports.makeKaminoWithdrawTx = makeKaminoWithdrawTx;
 exports.makeLoopTx = makeLoopTx;
+exports.makeMergeStakeAccountsTx = makeMergeStakeAccountsTx;
+exports.makeMintStakedLstIx = makeMintStakedLstIx;
+exports.makeMintStakedLstTx = makeMintStakedLstTx;
 exports.makePoolAddBankIx = makePoolAddBankIx3;
 exports.makePoolConfigureBankIx = makePoolConfigureBankIx3;
 exports.makePriorityFeeIx = makePriorityFeeIx;
 exports.makePriorityFeeMicroIx = makePriorityFeeMicroIx;
 exports.makePulseHealthIx = makePulseHealthIx2;
+exports.makeRedeemStakedLstIx = makeRedeemStakedLstIx;
+exports.makeRedeemStakedLstTx = makeRedeemStakedLstTx;
 exports.makeRefreshKaminoBanksIxs = makeRefreshKaminoBanksIxs;
 exports.makeRepayIx = makeRepayIx3;
 exports.makeRepayTx = makeRepayTx;