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

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
    */
@@ -44385,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 ---
@@ -46930,6 +46935,444 @@ async function makeJuplendDepositTx(params) {
   });
   return solanaTx;
 }
+async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
+  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
+    program.programId,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { endIndex: new BN11__default.default(endIndex) }
+  ) : await instructions_default.makeBeginFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { 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: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  ) : await instructions_default.makeEndFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function makeFlashLoanTx({
+  program,
+  marginfiAccount,
+  ixs,
+  bankMap,
+  blockhash,
+  addressLookupTableAccounts,
+  signers,
+  isSync
+}) {
+  const endIndex = ixs.length + 1;
+  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
+    marginfiAccount.balances,
+    ixs,
+    program
+  );
+  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
+    const b = bankMap.get(account.toBase58());
+    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
+    return b;
+  });
+  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    endIndex,
+    marginfiAccount.authority,
+    isSync
+  );
+  const endFlashLoanIx = await makeEndFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    projectedActiveBanks,
+    marginfiAccount.authority,
+    isSync
+  );
+  const message = new 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;
+}
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    bankMap,
+    depositOpts,
+    borrowOpts,
+    bankMetadataMap,
+    addressLookupTableAccounts,
+    connection,
+    oraclePrices,
+    crossbarUrl,
+    additionalIxs = []
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      {
+        mint: borrowOpts.borrowBank.mint,
+        tokenProgram: borrowOpts.tokenProgram
+      },
+      {
+        mint: depositOpts.depositBank.mint,
+        tokenProgram: depositOpts.tokenProgram
+      }
+    ]
+  });
+  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
+  );
+  const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
+  );
+  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
+    bankMetadataMap
+  );
+  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
+    setupIxs.push(
+      ...makeWrapSolIxs(marginfiAccount.authority, new 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,
+      ...updateJupLendRateIxs.instructions
+    ];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildLoopFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  borrowOpts,
+  depositOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  swapOpts,
+  overrideInferAccounts,
+  blockhash
+}) {
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
+  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
+    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
+  } else {
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      new web3_js.PublicKey(depositOpts.depositBank.mint),
+      marginfiAccount.authority,
+      true,
+      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+    );
+    const swapConstraints = await computeFlashloanSwapConstraints({
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+      primaryIx: {
+        type: "borrow",
+        bank: borrowOpts.borrowBank,
+        tokenProgram: borrowOpts.tokenProgram
+      },
+      secondaryIx: {
+        type: "deposit",
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram
+      },
+      overrideInferAccounts
+    });
+    const swapResponse = await getSwapIxsForFlashloan({
+      inputMint: borrowOpts.borrowBank.mint.toBase58(),
+      outputMint: depositOpts.depositBank.mint.toBase58(),
+      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
+      swapMode: "ExactIn",
+      authority: marginfiAccount.authority,
+      connection,
+      destinationTokenAccount,
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
+    });
+    sizeConstraintUsed = swapConstraints.sizeConstraint;
+    const outAmountThreshold = nativeToUi(
+      swapResponse.quoteResponse.otherAmountThreshold,
+      depositOpts.depositBank.mintDecimals
+    );
+    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
+    swapInstructions = swapResponse.swapInstructions;
+    setupInstructions = swapResponse.setupInstructions;
+    swapLookupTables = swapResponse.addressLookupTableAddresses;
+    swapQuote = swapResponse.quoteResponse;
+  }
+  const borrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowOpts.borrowBank,
+    bankMap,
+    tokenProgram: borrowOpts.tokenProgram,
+    amount: borrowOpts.borrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: false,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
+  });
+  let depositIxs;
+  switch (depositOpts.depositBank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
+        );
+      }
+      depositIxs = await makeKaminoDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
+        );
+      }
+      const driftMarketIndex = driftState.spotMarketState.marketIndex;
+      const driftOracle = driftState.spotMarketState.oracle;
+      depositIxs = await makeDriftDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        driftMarketIndex,
+        driftOracle,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    case 6 /* JUPLEND */: {
+      depositIxs = await makeJuplendDepositIx2({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    default: {
+      depositIxs = await makeDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+  }
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...swapInstructions,
+    ...depositIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint: sizeConstraintUsed,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
+  }
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededLoop(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    borrowIxs,
+    depositIxs,
+    amountToDeposit
+  };
+}
 async function makeRepayIx3({
   program,
   bank,
@@ -47384,882 +47827,6 @@ async function buildRepayWithCollatFlashloanTx({
   };
 }
 
-// src/services/account/utils/flashloan-size.utils.ts
-var SWAP_MERGE_OVERHEAD = 150;
-var FL_IX_OVERHEAD = 52;
-function compactU16Size(n) {
-  return n < 128 ? 1 : n < 16384 ? 2 : 3;
-}
-function computeV0TxSize(ixs, payerKey, luts) {
-  const keyMap = /* @__PURE__ */ new Map();
-  const payerStr = payerKey.toBase58();
-  keyMap.set(payerStr, { isSigner: true, isWritable: true });
-  const programIds = /* @__PURE__ */ new Set();
-  for (const ix of ixs) {
-    const progStr = ix.programId.toBase58();
-    programIds.add(progStr);
-    if (!keyMap.has(progStr)) {
-      keyMap.set(progStr, { isSigner: false, isWritable: false });
-    }
-    for (const meta of ix.keys) {
-      const keyStr = meta.pubkey.toBase58();
-      const existing = keyMap.get(keyStr);
-      if (existing) {
-        existing.isSigner = existing.isSigner || meta.isSigner;
-        existing.isWritable = existing.isWritable || meta.isWritable;
-      } else {
-        keyMap.set(keyStr, { isSigner: meta.isSigner, isWritable: meta.isWritable });
-      }
-    }
-  }
-  const lutLookup = /* @__PURE__ */ new Map();
-  for (let li = 0; li < luts.length; li++) {
-    const addresses = luts[li].state.addresses;
-    for (let ai = 0; ai < addresses.length; ai++) {
-      const addrStr = addresses[ai].toBase58();
-      if (!lutLookup.has(addrStr)) {
-        lutLookup.set(addrStr, { lutIdx: li, addrIdx: ai });
-      }
-    }
-  }
-  let numStaticKeys = 0;
-  let numWritableStaticKeys = 0;
-  const lutWritableIdxs = luts.map(() => /* @__PURE__ */ new Set());
-  const lutReadonlyIdxs = luts.map(() => /* @__PURE__ */ new Set());
-  for (const [keyStr, props] of keyMap) {
-    if (props.isSigner || programIds.has(keyStr)) {
-      numStaticKeys++;
-      if (props.isWritable) numWritableStaticKeys++;
-      continue;
-    }
-    const lutEntry = lutLookup.get(keyStr);
-    if (lutEntry) {
-      if (props.isWritable) {
-        lutWritableIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
-      } else {
-        lutReadonlyIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
-      }
-    } else {
-      numStaticKeys++;
-      if (props.isWritable) numWritableStaticKeys++;
-    }
-  }
-  const fixedOverhead = 101;
-  const staticKeysSection = compactU16Size(numStaticKeys) + numStaticKeys * 32;
-  let ixSection = compactU16Size(ixs.length);
-  for (const ix of ixs) {
-    const numAccounts = ix.keys.length;
-    ixSection += 1 + // programId index
-    compactU16Size(numAccounts) + numAccounts + // account key indexes
-    compactU16Size(ix.data.length) + ix.data.length;
-  }
-  let numUsedLuts = 0;
-  let lutSection = 0;
-  for (let li = 0; li < luts.length; li++) {
-    const wCount = lutWritableIdxs[li].size;
-    const rCount = lutReadonlyIdxs[li].size;
-    if (wCount === 0 && rCount === 0) continue;
-    numUsedLuts++;
-    lutSection += 32 + // LUT address
-    compactU16Size(wCount) + wCount + // writable indexes
-    compactU16Size(rCount) + rCount;
-  }
-  lutSection += compactU16Size(numUsedLuts);
-  let totalLutKeys = 0;
-  for (let li = 0; li < luts.length; li++) {
-    totalLutKeys += lutWritableIdxs[li].size + lutReadonlyIdxs[li].size;
-  }
-  const accountCount = numStaticKeys + totalLutKeys;
-  let totalLutWritableKeys = 0;
-  for (let li = 0; li < luts.length; li++) {
-    totalLutWritableKeys += lutWritableIdxs[li].size;
-  }
-  const writableAccountCount = numWritableStaticKeys + totalLutWritableKeys;
-  const size = fixedOverhead + staticKeysSection + ixSection + lutSection + 1;
-  return { size, accountCount, writableAccountCount };
-}
-function computeFlashLoanNonSwapBudget({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  addressLookupTableAccounts
-}) {
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((key) => {
-    const b = bankMap.get(key.toBase58());
-    if (!b) throw new Error(`Bank ${key.toBase58()} not found in computeFlashLoanNonSwapBudget`);
-    return b;
-  });
-  const endIndex = ixs.length + 1;
-  const beginFlIx = sync_instructions_default.makeBeginFlashLoanIx(
-    program.programId,
-    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
-    { endIndex: new BN11__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,
-        authority: marginfiAccount.authority,
-        withdrawAll: false,
-        isSync: true,
-        opts
-      });
-    }
-  }
-}
-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/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(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    { 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: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  ) : await instructions_default.makeEndFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function makeFlashLoanTx({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  blockhash,
-  addressLookupTableAccounts,
-  signers,
-  isSync
-}) {
-  const endIndex = ixs.length + 1;
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
-    const b = bankMap.get(account.toBase58());
-    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
-    return b;
-  });
-  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    endIndex,
-    marginfiAccount.authority,
-    isSync
-  );
-  const endFlashLoanIx = await makeEndFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    projectedActiveBanks,
-    marginfiAccount.authority,
-    isSync
-  );
-  const message = new 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;
-}
-
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    bankMap,
-    depositOpts,
-    borrowOpts,
-    bankMetadataMap,
-    addressLookupTableAccounts,
-    connection,
-    oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
-  } = params;
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      {
-        mint: borrowOpts.borrowBank.mint,
-        tokenProgram: borrowOpts.tokenProgram
-      },
-      {
-        mint: depositOpts.depositBank.mint,
-        tokenProgram: depositOpts.tokenProgram
-      }
-    ]
-  });
-  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
-  );
-  const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
-  );
-  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
-    marginfiAccount,
-    bankMap,
-    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
-    bankMetadataMap
-  );
-  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
-    ...params,
-    blockhash
-  });
-  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
-    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
-      return false;
-    }
-    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
-        return false;
-      }
-    }
-    return true;
-  });
-  setupIxs.push(...jupiterSetupInstructions);
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  let additionalTxs = [];
-  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
-    setupIxs.push(
-      ...makeWrapSolIxs(marginfiAccount.authority, new 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,
-      ...updateJupLendRateIxs.instructions
-    ];
-    const txs = splitInstructionsToFitTransactions([], ixs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
-    );
-  }
-  if (updateFeedIxs.length > 0) {
-    const message = new web3_js.TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
-    );
-  }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildLoopFlashloanTx({
-  program,
-  marginfiAccount,
-  bankMap,
-  borrowOpts,
-  depositOpts,
-  bankMetadataMap,
-  addressLookupTableAccounts,
-  connection,
-  swapOpts,
-  overrideInferAccounts,
-  blockhash
-}) {
-  const cuRequestIxs = [
-    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  let amountToDeposit;
-  let swapInstructions = [];
-  let setupInstructions = [];
-  let swapLookupTables = [];
-  let swapQuote;
-  let sizeConstraintUsed = 0;
-  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
-    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
-  } else {
-    const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new web3_js.PublicKey(depositOpts.depositBank.mint),
-      marginfiAccount.authority,
-      true,
-      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
-    );
-    const swapConstraints = await computeFlashloanSwapConstraints({
-      program,
-      marginfiAccount,
-      bankMap,
-      bankMetadataMap,
-      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
-      primaryIx: {
-        type: "borrow",
-        bank: borrowOpts.borrowBank,
-        tokenProgram: borrowOpts.tokenProgram
-      },
-      secondaryIx: {
-        type: "deposit",
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram
-      },
-      overrideInferAccounts
-    });
-    const swapResponse = await getSwapIxsForFlashloan({
-      inputMint: borrowOpts.borrowBank.mint.toBase58(),
-      outputMint: depositOpts.depositBank.mint.toBase58(),
-      amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
-      swapMode: "ExactIn",
-      authority: marginfiAccount.authority,
-      connection,
-      destinationTokenAccount,
-      swapOpts,
-      sizeConstraint: swapConstraints.sizeConstraint,
-      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
-    });
-    sizeConstraintUsed = swapConstraints.sizeConstraint;
-    const outAmountThreshold = nativeToUi(
-      swapResponse.quoteResponse.otherAmountThreshold,
-      depositOpts.depositBank.mintDecimals
-    );
-    amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
-    swapInstructions = swapResponse.swapInstructions;
-    setupInstructions = swapResponse.setupInstructions;
-    swapLookupTables = swapResponse.addressLookupTableAddresses;
-    swapQuote = swapResponse.quoteResponse;
-  }
-  const borrowIxs = await makeBorrowIx3({
-    program,
-    bank: borrowOpts.borrowBank,
-    bankMap,
-    tokenProgram: borrowOpts.tokenProgram,
-    amount: borrowOpts.borrowAmount,
-    marginfiAccount,
-    authority: marginfiAccount.authority,
-    isSync: false,
-    opts: {
-      createAtas: false,
-      wrapAndUnwrapSol: false,
-      overrideInferAccounts
-    }
-  });
-  let depositIxs;
-  switch (depositOpts.depositBank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
-        );
-      }
-      depositIxs = await makeKaminoDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        reserve,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          depositOpts.depositBank.address.toBase58(),
-          depositOpts.depositBank.mint.toBase58(),
-          depositOpts.depositBank.tokenSymbol
-        );
-      }
-      const driftMarketIndex = driftState.spotMarketState.marketIndex;
-      const driftOracle = driftState.spotMarketState.oracle;
-      depositIxs = await makeDriftDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex,
-        driftOracle,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    case 6 /* JUPLEND */: {
-      depositIxs = await makeJuplendDepositIx2({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    default: {
-      depositIxs = await makeDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountToDeposit,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-  }
-  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-  const allNonFlIxs = [
-    ...cuRequestIxs,
-    ...borrowIxs.instructions,
-    ...swapInstructions,
-    ...depositIxs.instructions
-  ];
-  if (swapInstructions.length > 0) {
-    compileFlashloanPrecheck({
-      allIxs: allNonFlIxs,
-      payer: marginfiAccount.authority,
-      luts,
-      sizeConstraint: sizeConstraintUsed,
-      swapIxCount: swapInstructions.length,
-      swapLutCount: swapLookupTables.length
-    });
-  }
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: allNonFlIxs
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededLoop(
-      txSize,
-      totalKeys,
-      swapOpts.swapConfig?.provider
-    );
-  }
-  return {
-    flashloanTx,
-    setupInstructions,
-    swapQuote,
-    borrowIxs,
-    depositIxs,
-    amountToDeposit
-  };
-}
-
 // src/services/account/actions/emissions.ts
 async function makeClearEmissionsIx(program, marginfiAccount, banks, bankAddress) {
   const bank = banks.get(bankAddress.toBase58());
@@ -48687,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
@@ -48948,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
@@ -48962,179 +48529,6 @@ async function buildSwapDebtFlashloanTx({
     repayIxs
   };
 }
-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 */
-  });
-}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -49983,7 +49377,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: {
@@ -50241,140 +49635,575 @@ var getExactOutEstimate = async (params) => {
       );
     }
   }
-  const firstProvider = attempts[0]?.provider ?? "Swap";
-  throw TransactionBuildingError.swapQuoteFailed(
-    firstProvider,
-    inputMint,
-    outputMint,
-    lastError?.message ?? "No swap route available"
-  );
-};
-function mapJupiterQuoteToSwapQuoteResult(quote) {
-  return {
-    inAmount: quote.inAmount,
-    outAmount: quote.outAmount,
-    otherAmountThreshold: quote.otherAmountThreshold,
-    slippageBps: quote.slippageBps,
-    platformFee: quote.platformFee ? {
-      amount: quote.platformFee.amount ?? "0",
-      feeBps: quote.platformFee.feeBps ?? 0
-    } : void 0,
-    priceImpactPct: quote.priceImpactPct,
-    contextSlot: quote.contextSlot,
-    timeTaken: quote.timeTaken,
-    provider: "JUPITER" /* JUPITER */
-  };
-}
-
-// src/services/account/utils/jupiter.utils.ts
-var REFERRAL_PROGRAM_ID = new 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
-  };
+  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 JUPITER_MAX_ACCOUNTS_MARGIN = 4;
+  const maxAccounts = maxSwapAccounts !== void 0 ? maxSwapAccounts - JUPITER_MAX_ACCOUNTS_MARGIN : 40;
+  const swapQuote = await jupiterApiClient.quoteGet({
+    ...finalQuoteParams,
+    maxAccounts
+  });
+  const swapInstructionResponse = await jupiterApiClient.swapInstructionsPost({
+    swapRequest: {
+      quoteResponse: swapQuote,
+      userPublicKey: authority.toBase58(),
+      feeAccount: hasFeeAccount ? feeAccount : void 0,
+      wrapAndUnwrapSol: false,
+      destinationTokenAccount: destinationTokenAccount.toBase58()
+    }
+  });
+  const lutAddresses = swapInstructionResponse.addressLookupTableAddresses;
+  const lutAccountsRaw = await connection.getMultipleAccountsInfo(
+    lutAddresses.map((address) => new 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
+      });
+    }
+  }
 }
-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
@@ -52638,6 +52467,230 @@ function getValidatorVoteAccountByBank() {
   }
   return _voteAccountByBank;
 }
+async function computeStakedBankMultipliers(stakedBanks, connection) {
+  const multiplierByBank = /* @__PURE__ */ new Map();
+  if (stakedBanks.length === 0) {
+    return multiplierByBank;
+  }
+  const metadataMap = getStakedBankMetadataMap();
+  const stakedBankAddresses = [];
+  const poolStakeAddresses = [];
+  const lstMintAddresses = [];
+  for (const bank of stakedBanks) {
+    const metadata = metadataMap.get(bank.address.toBase58());
+    if (!metadata) {
+      multiplierByBank.set(bank.address.toBase58(), new BigNumber3__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;
@@ -55074,66 +55127,6 @@ var MarginfiAccountWrapper = class {
     return this.account.getHealthCheckAccounts(this.client.bankMap, mandatoryBanks, excludedBanks);
   }
   // ----------------------------------------------------------------------------
-  // Native stake actions
-  // Note: These call standalone action functions directly rather than routing
-  // through this.account because they interact with the SPL stake pool program,
-  // not the marginfi program. No MarginfiAccount state is needed.
-  // ----------------------------------------------------------------------------
-  /**
-   * Creates a transaction to mint LST from a native stake account.
-   *
-   * Converts a native stake account (or a portion of it) into LST tokens
-   * by depositing the stake into the single-validator pool.
-   *
-   * @param amount - SOL amount to convert (in UI units)
-   * @param stakeAccountPk - The stake account to convert
-   * @param validator - The validator vote account
-   */
-  async makeMintStakedLstTx(amount, stakeAccountPk, validator) {
-    return makeMintStakedLstTx({
-      amount,
-      authority: this.authority,
-      stakeAccountPk,
-      validator,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  /**
-   * Creates a transaction to redeem LST tokens back to a native stake account.
-   *
-   * Burns LST tokens and withdraws the underlying stake into a new stake account.
-   *
-   * @param amount - LST amount to redeem (in UI units)
-   * @param validator - The validator vote account
-   */
-  async makeRedeemStakedLstTx(amount, validator) {
-    return makeRedeemStakedLstTx({
-      amount,
-      authority: this.authority,
-      validator,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  /**
-   * Creates a transaction to merge two stake accounts.
-   *
-   * Both accounts must share the same authorized staker/withdrawer and vote account.
-   *
-   * @param sourceStakeAccount - The stake account to merge from (will be consumed)
-   * @param destinationStakeAccount - The stake account to merge into
-   */
-  async makeMergeStakeAccountsTx(sourceStakeAccount, destinationStakeAccount) {
-    return makeMergeStakeAccountsTx({
-      authority: this.authority,
-      sourceStakeAccount,
-      destinationStakeAccount,
-      connection: this.client.program.provider.connection,
-      luts: this.client.addressLookupTables
-    });
-  }
-  // ----------------------------------------------------------------------------
   // Helper methods
   // ----------------------------------------------------------------------------
   /**
@@ -55403,56 +55396,11 @@ var Project0Client = class _Project0Client {
           break;
       }
     });
-    const stakedBanks = banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */);
-    if (stakedBanks.length > 0) {
-      const metadataMap = getStakedBankMetadataMap();
-      const stakedBankAddresses = [];
-      const poolStakeAddresses = [];
-      const lstMintAddresses = [];
-      for (const bank of stakedBanks) {
-        const metadata = metadataMap.get(bank.address.toBase58());
-        if (!metadata) {
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__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) {
-        const allAddresses = [
-          ...poolStakeAddresses.map((a) => a.toBase58()),
-          ...lstMintAddresses.map((a) => a.toBase58())
-        ];
-        const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(
-          connection,
-          allAddresses
-        );
-        const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
-        const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
-        for (let i = 0; i < stakedBankAddresses.length; i++) {
-          const bankAddr = stakedBankAddresses[i];
-          const poolStakeInfo = poolStakeInfos[i];
-          const lstMintInfo = lstMintInfos[i];
-          if (!poolStakeInfo || !lstMintInfo) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3__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) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3__default.default(1));
-            continue;
-          }
-          const LAMPORTS_PER_SOL5 = 1e9;
-          const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL5, 0);
-          const multiplier = new BigNumber3__default.default(adjustedStake).dividedBy(lstMintSupply);
-          assetShareMultiplierByBank.set(bankAddr, multiplier);
-        }
-      }
-    }
+    const stakedMultipliers = await computeStakedBankMultipliers(
+      banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */),
+      connection
+    );
+    stakedMultipliers.forEach((v, k) => assetShareMultiplierByBank.set(k, v));
     const emodePairs = getEmodePairs(banksArray);
     return new _Project0Client(
       program,
@@ -55634,6 +55582,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;