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

package/dist/index.cjs

@@ -11,6 +11,8 @@ var bufferLayoutUtils = require('@solana/buffer-layout-utils');
 var buffer = require('buffer');
 var borsh$1 = require('borsh');
 var borsh = require('@coral-xyz/borsh');
+var WebSocket = require('ws');
+var msgpack = require('@msgpack/msgpack');
 var api = require('@jup-ag/api');
 var onDemand = require('@switchboard-xyz/on-demand');
 var common = require('@switchboard-xyz/common');
@@ -39,6 +41,7 @@ var BigNumber3__default = /*#__PURE__*/_interopDefault(BigNumber3);
 var BN11__default = /*#__PURE__*/_interopDefault(BN11);
 var Decimal3__default = /*#__PURE__*/_interopDefault(Decimal3);
 var borsh__namespace = /*#__PURE__*/_interopNamespace(borsh);
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
 
 // src/config.ts
 
@@ -115,12 +118,15 @@ 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";
   TransactionBuildingErrorCode2["JUPLEND_STATE_NOT_FOUND"] = "JUPLEND_STATE_NOT_FOUND";
+  TransactionBuildingErrorCode2["SWITCHBOARD_FEED_UPDATE_FAILED"] = "SWITCHBOARD_FEED_UPDATE_FAILED";
+  TransactionBuildingErrorCode2["SWAP_QUOTE_FAILED"] = "SWAP_QUOTE_FAILED";
   return TransactionBuildingErrorCode2;
 })(TransactionBuildingErrorCode || {});
 var TransactionBuildingError = class _TransactionBuildingError extends Error {
@@ -135,21 +141,25 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       Error.captureStackTrace(this, _TransactionBuildingError);
     }
   }
-  /**
-   * Jupiter swap instruction size exceeds available transaction size
-   */
-  static jupiterSwapSizeExceededLoop(bytes, accountKeys) {
+  static swapSizeExceededLoop(bytes, accountKeys, provider) {
+    return new _TransactionBuildingError(
+      "SWAP_SIZE_EXCEEDED_LOOP" /* SWAP_SIZE_EXCEEDED_LOOP */,
+      `${provider ?? "Swap"} instruction size exceeds available transaction size`,
+      { bytes, accountKeys, provider }
+    );
+  }
+  static swapSizeExceededRepay(bytes, accountKeys, provider) {
     return new _TransactionBuildingError(
-      "JUPITER_SWAP_SIZE_EXCEEDED_LOOP" /* JUPITER_SWAP_SIZE_EXCEEDED_LOOP */,
-      "Jupiter swap instruction size exceeds available transaction size",
-      { bytes, accountKeys }
+      "SWAP_SIZE_EXCEEDED_REPAY" /* SWAP_SIZE_EXCEEDED_REPAY */,
+      `${provider ?? "Swap"} instruction size exceeds available transaction size`,
+      { bytes, accountKeys, provider }
     );
   }
-  static jupiterSwapSizeExceededRepay(bytes, accountKeys) {
+  static swapSizeExceededPositionSwap(bytes, accountKeys, provider) {
     return new _TransactionBuildingError(
-      "JUPITER_SWAP_SIZE_EXCEEDED_REPAY" /* JUPITER_SWAP_SIZE_EXCEEDED_REPAY */,
-      "Jupiter swap instruction size exceeds available transaction size",
-      { bytes, accountKeys }
+      "SWAP_SIZE_EXCEEDED_POSITION_SWAP" /* SWAP_SIZE_EXCEEDED_POSITION_SWAP */,
+      `${provider ?? "Swap"} instruction size exceeds available transaction size`,
+      { bytes, accountKeys, provider }
     );
   }
   /**
@@ -193,6 +203,26 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { bankAddress, bankMint, bankSymbol }
     );
   }
+  /**
+   * Failed to update Switchboard price feeds
+   */
+  static switchboardFeedUpdateFailed(oracleKeys, reason) {
+    return new _TransactionBuildingError(
+      "SWITCHBOARD_FEED_UPDATE_FAILED" /* SWITCHBOARD_FEED_UPDATE_FAILED */,
+      `Switchboard feed update failed: ${reason}`,
+      { oracleKeys, reason }
+    );
+  }
+  /**
+   * Failed to get a swap quote from any provider
+   */
+  static swapQuoteFailed(provider, inputMint, outputMint, reason) {
+    return new _TransactionBuildingError(
+      "SWAP_QUOTE_FAILED" /* SWAP_QUOTE_FAILED */,
+      `${provider} swap quote failed for ${inputMint} \u2192 ${outputMint}: ${reason}`,
+      { provider, inputMint, outputMint, reason }
+    );
+  }
   /**
    * Generic escape hatch for custom errors
    */
@@ -345,6 +375,7 @@ var MAX_U64 = BigInt("18446744073709551615").toString();
 
 // src/constants/transaction.consts.ts
 var MAX_TX_SIZE = 1232;
+var MAX_ACCOUNT_LOCKS = 64;
 var BUNDLE_TX_SIZE = 81;
 var PRIORITY_TX_SIZE = 44;
 var WSOL_MINT = new web3_js.PublicKey("So11111111111111111111111111111111111111112");
@@ -14893,8 +14924,40 @@ function getTxSize(tx) {
   const signaturesSize = (numRequiredSignatures - numSigners) * 64 + 1;
   try {
     const baseTxSize = isVersioned ? tx.serialize().length : tx.serialize({ requireAllSignatures: false, verifySignatures: false }).length;
-    return baseTxSize + feePayerSize + signaturesSize;
-  } catch {
+    const totalSize = baseTxSize + feePayerSize + signaturesSize;
+    if (isVersioned && totalSize > 1232) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const lutWritable = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+      const lutReadonly = addressTableLookups.reduce((s, l) => s + l.readonlyIndexes.length, 0);
+      console.warn("[getTxSize] oversized TX", {
+        totalSize,
+        overshoot: totalSize - 1232,
+        staticKeys: staticAccountKeys.length,
+        numSignatures: header.numRequiredSignatures,
+        numLuts: addressTableLookups.length,
+        lutWritable,
+        lutReadonly,
+        totalAccounts: staticAccountKeys.length + lutWritable + lutReadonly
+      });
+    }
+    return totalSize;
+  } catch (err) {
+    if (isVersioned) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const lutWritable = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+      const lutReadonly = addressTableLookups.reduce((s, l) => s + l.readonlyIndexes.length, 0);
+      console.warn("[getTxSize] serialize failed", {
+        error: err.message,
+        staticKeys: staticAccountKeys.length,
+        numSignatures: header.numRequiredSignatures,
+        numLuts: addressTableLookups.length,
+        lutWritable,
+        lutReadonly,
+        totalAccounts: staticAccountKeys.length + lutWritable + lutReadonly
+      });
+    } else {
+      console.warn("[getTxSize] serialize failed", { error: err.message });
+    }
     return 9999;
   }
 }
@@ -14909,6 +14972,47 @@ function getAccountKeys(tx, lookupTableAccounts) {
     } else {
       return tx.compileMessage().getAccountKeys().length;
     }
+  } catch (err) {
+    console.warn("[getAccountKeys] decompile failed", { error: err.message });
+    return 9999;
+  }
+}
+function getWritableAccountKeys(tx) {
+  const isVersioned = isV0Tx(tx);
+  try {
+    if (isVersioned) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
+      const writableLut = addressTableLookups.reduce(
+        (sum, lookup) => sum + lookup.writableIndexes.length,
+        0
+      );
+      return writableStatic + writableLut;
+    } else {
+      const message = tx.compileMessage();
+      const { numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts } = message.header;
+      const totalKeys = message.accountKeys.length;
+      const writableSigned = numRequiredSignatures - numReadonlySignedAccounts;
+      const writableUnsigned = totalKeys - numRequiredSignatures - numReadonlyUnsignedAccounts;
+      return writableSigned + writableUnsigned;
+    }
+  } catch {
+    return 9999;
+  }
+}
+function getTotalAccountKeys(tx) {
+  const isVersioned = isV0Tx(tx);
+  try {
+    if (isVersioned) {
+      const { staticAccountKeys, addressTableLookups } = tx.message;
+      const lutAccounts = addressTableLookups.reduce(
+        (sum, lookup) => sum + lookup.writableIndexes.length + lookup.readonlyIndexes.length,
+        0
+      );
+      return staticAccountKeys.length + lutAccounts;
+    } else {
+      return tx.compileMessage().accountKeys.length;
+    }
   } catch {
     return 9999;
   }
@@ -20146,6 +20250,14 @@ var HealthCacheSimulationError = class _HealthCacheSimulationError extends Error
   }
 };
 
+// src/services/account/types/action.types.ts
+var SwapProvider = /* @__PURE__ */ ((SwapProvider2) => {
+  SwapProvider2["JUPITER"] = "JUPITER";
+  SwapProvider2["TITAN"] = "TITAN";
+  SwapProvider2["DFLOW"] = "DFLOW";
+  return SwapProvider2;
+})(SwapProvider || {});
+
 // src/services/account/utils/deserialize.utils.ts
 var EMPTY_HEALTH_CACHE = {
   assetValue: {
@@ -44194,6 +44306,346 @@ function makeUpdateJupLendRate({ lendingState }) {
     lendingState.rewardsRateModel
   );
 }
+var SUBPROTOCOL = "v1.api.titan.ag";
+var UINT64_MAX = (1n << 64n) - 1n;
+function toBigInt(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n || value > UINT64_MAX) {
+      throw new RangeError(`Amount out of uint64 range: ${value}`);
+    }
+    return value;
+  }
+  if (!Number.isInteger(value)) {
+    throw new TypeError(`Amount must be a whole number, got ${value}`);
+  }
+  if (value < 0) {
+    throw new RangeError(`Amount must be non-negative, got ${value}`);
+  }
+  return BigInt(value);
+}
+var ConnectionClosed = class _ConnectionClosed extends Error {
+  code;
+  reason;
+  constructor(code, reason) {
+    super(`Client WebSocket closed with code ${code}: ${reason}`);
+    this.name = "ConnectionClosed";
+    Object.setPrototypeOf(this, _ConnectionClosed.prototype);
+    this.code = code;
+    this.reason = reason;
+  }
+};
+var ErrorResponse = class _ErrorResponse extends Error {
+  response;
+  constructor(response) {
+    super(`Request ${response.requestId} failed with code ${response.code}: ${response.message}`);
+    this.name = "ErrorResponse";
+    Object.setPrototypeOf(this, _ErrorResponse.prototype);
+    this.response = response;
+  }
+};
+var StreamError = class _StreamError extends Error {
+  streamId;
+  errorCode;
+  errorMessage;
+  constructor(packet) {
+    const code = packet.errorCode ?? 0;
+    const message = packet.errorMessage ?? "";
+    super(`Stream ${packet.id} ended with error code ${code}: ${message}`);
+    this.name = "StreamError";
+    Object.setPrototypeOf(this, _StreamError.prototype);
+    this.streamId = packet.id;
+    this.errorCode = code;
+    this.errorMessage = message;
+  }
+};
+var encoder = new msgpack.Encoder({ useBigInt64: true });
+var decoder = new msgpack.Decoder({ useBigInt64: true });
+var V1Client = class _V1Client {
+  socket;
+  nextId = 0;
+  _closed = false;
+  _closing = false;
+  pending = /* @__PURE__ */ new Map();
+  streams = /* @__PURE__ */ new Map();
+  streamStopping = /* @__PURE__ */ new Map();
+  closeListeners = [];
+  // --- Static connect ---
+  static connect(url) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket__default.default(url, [SUBPROTOCOL]);
+      ws.binaryType = "arraybuffer";
+      const onOpen = () => {
+        ws.off("error", onError);
+        ws.off("close", onClose);
+        resolve(new _V1Client(ws));
+      };
+      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 ---
+  constructor(socket) {
+    this.socket = socket;
+    this.socket.on("message", (data) => {
+      this.handleMessage(data);
+    });
+    this.socket.on("close", (code, reason) => {
+      this.handleClose(code, reason.toString());
+    });
+    this.socket.on("error", (err) => {
+      this.handleError(err);
+    });
+  }
+  nextRequestId() {
+    return this.nextId++;
+  }
+  // --- Public API ---
+  get closed() {
+    return this._closed;
+  }
+  close() {
+    if (this._closed) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this.closeListeners.push({ resolve, reject });
+      if (!this._closing) {
+        this._closing = true;
+        this.socket.close();
+      }
+    });
+  }
+  newSwapQuoteStream(params) {
+    const requestId = this.nextRequestId();
+    const promise = new Promise(
+      (resolve, reject) => {
+        this.pending.set(requestId, {
+          resolve,
+          reject,
+          kind: "NewSwapQuoteStream"
+        });
+      }
+    );
+    const normalized = {
+      ...params,
+      swap: { ...params.swap, amount: toBigInt(params.swap.amount) }
+    };
+    const message = {
+      id: requestId,
+      data: { NewSwapQuoteStream: normalized }
+    };
+    this.send(message);
+    return promise;
+  }
+  stopStream(streamId) {
+    const requestId = this.nextRequestId();
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(requestId, {
+        resolve,
+        reject,
+        kind: "StopStream"
+      });
+    });
+    const message = {
+      id: requestId,
+      data: { StopStream: { id: streamId } }
+    };
+    this.send(message);
+    return promise;
+  }
+  // --- Send ---
+  send(message) {
+    try {
+      const encoded = encoder.encode(message);
+      this.socket.send(encoded);
+    } catch (err) {
+      const req = this.pending.get(message.id);
+      if (req) {
+        this.pending.delete(message.id);
+        req.reject(err);
+      }
+    }
+  }
+  // --- Message handling ---
+  handleMessage(raw) {
+    let buf;
+    if (raw instanceof ArrayBuffer) {
+      buf = new Uint8Array(raw);
+    } else if (Buffer.isBuffer(raw)) {
+      buf = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+    } else if (Array.isArray(raw)) {
+      buf = new Uint8Array(Buffer.concat(raw));
+    } else {
+      return;
+    }
+    let message;
+    try {
+      message = decoder.decode(buf);
+    } catch {
+      this.socket.close(3002, "failed to decode message");
+      return;
+    }
+    if ("Response" in message) {
+      this.handleResponse(message.Response);
+    } else if ("Error" in message) {
+      this.handleResponseError(message.Error);
+    } else if ("StreamData" in message) {
+      this.handleStreamData(message.StreamData);
+    } else if ("StreamEnd" in message) {
+      this.handleStreamEnd(message.StreamEnd);
+    }
+  }
+  handleResponse(msg) {
+    const req = this.pending.get(msg.requestId);
+    if (!req) return;
+    this.pending.delete(msg.requestId);
+    if ("NewSwapQuoteStream" in msg.data && req.kind === "NewSwapQuoteStream") {
+      const streamInfo = msg.stream;
+      if (!streamInfo) {
+        req.reject(new Error("No stream associated with NewSwapQuoteStream response"));
+        return;
+      }
+      const stream = new ReadableStream({
+        start: (controller) => {
+          this.streams.set(streamInfo.id, controller);
+        },
+        cancel: () => {
+          return this.cancelStream(streamInfo.id);
+        }
+      });
+      const result = {
+        response: msg.data.NewSwapQuoteStream,
+        stream,
+        streamId: streamInfo.id
+      };
+      req.resolve(result);
+    } else if ("StreamStopped" in msg.data && req.kind === "StopStream") {
+      req.resolve(msg.data.StreamStopped);
+    } else {
+      req.reject(new Error(`Unexpected response type for ${req.kind}`));
+    }
+  }
+  handleResponseError(error) {
+    const req = this.pending.get(error.requestId);
+    if (!req) return;
+    this.pending.delete(error.requestId);
+    req.reject(new ErrorResponse(error));
+  }
+  handleStreamData(packet) {
+    const controller = this.streams.get(packet.id);
+    if (!controller) return;
+    if (packet.payload.SwapQuotes !== void 0) {
+      controller.enqueue(packet.payload.SwapQuotes);
+    }
+  }
+  handleStreamEnd(packet) {
+    const controller = this.streams.get(packet.id);
+    if (!controller) return;
+    this.streams.delete(packet.id);
+    this.streamStopping.delete(packet.id);
+    if (packet.errorCode !== void 0) {
+      controller.error(new StreamError(packet));
+    } else {
+      controller.close();
+    }
+  }
+  async cancelStream(streamId) {
+    if (this.streamStopping.get(streamId) || !this.streams.has(streamId)) return;
+    this.streamStopping.set(streamId, true);
+    await this.stopStream(streamId);
+  }
+  // --- Connection lifecycle ---
+  rejectAll(error) {
+    for (const req of this.pending.values()) {
+      req.reject(error);
+    }
+    this.pending.clear();
+    for (const controller of this.streams.values()) {
+      controller.error(error);
+    }
+    this.streams.clear();
+    this.streamStopping.clear();
+  }
+  handleClose(code, reason) {
+    this._closed = true;
+    this.rejectAll(new ConnectionClosed(code, reason));
+    for (const listener of this.closeListeners) {
+      listener.resolve();
+    }
+    this.closeListeners = [];
+  }
+  handleError(err) {
+    this.rejectAll(err);
+    this.socket.close(3002);
+  }
+};
+function deserializeSerializedInstruction(ix) {
+  return new web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(Buffer.from(ix.p, "base64")),
+    keys: ix.a.map((account) => ({
+      pubkey: new web3_js.PublicKey(Buffer.from(account.p, "base64")),
+      isSigner: account.s,
+      isWritable: account.w
+    })),
+    data: Buffer.from(ix.d, "base64")
+  });
+}
+function selectBestRoute(quotes, swapMode) {
+  const routes = Object.values(quotes);
+  if (routes.length === 0) return null;
+  return routes.reduce((best, route) => {
+    if (swapMode === "ExactIn") {
+      return route.outAmount > best.outAmount ? route : best;
+    } else {
+      return route.inAmount < best.inAmount ? route : best;
+    }
+  });
+}
+function buildSwapQuoteResult(route, swapMode) {
+  const slippageBps = route.slippageBps;
+  let otherAmountThreshold;
+  if (swapMode === "ExactIn") {
+    otherAmountThreshold = String(Math.floor(route.outAmount * (1 - slippageBps / 1e4)));
+  } else {
+    otherAmountThreshold = String(Math.ceil(route.inAmount * (1 + slippageBps / 1e4)));
+  }
+  return {
+    inAmount: String(route.inAmount),
+    outAmount: String(route.outAmount),
+    otherAmountThreshold,
+    slippageBps,
+    platformFee: route.platformFee ? {
+      amount: String(route.platformFee.amount),
+      feeBps: route.platformFee.fee_bps
+    } : void 0,
+    contextSlot: route.contextSlot,
+    timeTaken: route.timeTaken
+  };
+}
+async function resolveLookupTables(connection, lutPubkeys) {
+  if (lutPubkeys.length === 0) return [];
+  const lutAccountsRaw = await connection.getMultipleAccountsInfo(lutPubkeys);
+  return lutAccountsRaw.map((accountInfo, index) => {
+    if (!accountInfo) return null;
+    return new web3_js.AddressLookupTableAccount({
+      key: lutPubkeys[index],
+      state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
+    });
+  }).filter((account) => account !== null);
+}
 
 // src/vendor/klend/utils/klend/interest-rate.utils.ts
 function getKaminoTotalSupply(reserve) {
@@ -46715,18 +47167,18 @@ async function buildLoopFlashloanTx({
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   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)) {
-    swapResult.push({
-      amountToDeposit: borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0),
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
       new web3_js.PublicKey(depositOpts.depositBank.mint),
@@ -46734,36 +47186,46 @@ async function buildLoopFlashloanTx({
       true,
       depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const swapResponse = await getJupiterSwapIxsForFlashloan({
-      quoteParams: {
-        inputMint: borrowOpts.borrowBank.mint.toBase58(),
-        outputMint: depositOpts.depositBank.mint.toBase58(),
-        amount: uiToNative(borrowOpts.borrowAmount, borrowOpts.borrowBank.mintDecimals).toNumber(),
-        dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-        slippageBps: swapOpts.jupiterOptions?.slippageBps ?? void 0,
-        swapMode: "ExactIn",
-        platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps ?? void 0,
-        onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
+    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,
-      configParams: swapOpts.jupiterOptions?.configParams
-    });
-    swapResponse.forEach((response) => {
-      const outAmountThreshold = nativeToUi(
-        response.quoteResponse.otherAmountThreshold,
-        depositOpts.depositBank.mintDecimals
-      );
-      const amountToDeposit = outAmountThreshold + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
-      swapResult.push({
-        amountToDeposit,
-        swapInstructions: [response.swapInstruction],
-        setupInstructions: response.setupInstructions,
-        swapLookupTables: response.addressLookupTableAddresses,
-        quoteResponse: response.quoteResponse
-      });
+      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,
@@ -46780,140 +47242,136 @@ async function buildLoopFlashloanTx({
       overrideInferAccounts
     }
   });
-  for (const [index, item] of swapResult.entries()) {
-    const {
-      amountToDeposit,
-      swapInstructions,
-      setupInstructions,
-      swapLookupTables,
-      quoteResponse
-    } = item;
-    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;
+  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
+        );
       }
-      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
-          );
+      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
         }
-        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;
-      }
+      });
+      break;
     }
-    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-    const flashloanParams = {
-      program,
-      marginfiAccount,
-      bankMap,
-      addressLookupTableAccounts: luts,
-      blockhash
-    };
-    const flashloanTx = await makeFlashLoanTx({
-      ...flashloanParams,
-      ixs: [
-        ...cuRequestIxs,
-        ...borrowIxs.instructions,
-        ...swapInstructions,
-        ...depositIxs.instructions
-      ]
-    });
-    const txSize = getTxSize(flashloanTx);
-    const keySize = getAccountKeys(flashloanTx, luts);
-    const isLast = index === swapResult.length - 1;
-    if (txSize > MAX_TX_SIZE || keySize > 64) {
-      if (isLast) {
-        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
-      } else {
-        continue;
+    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
+        );
       }
-    } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        borrowIxs,
-        depositIxs,
-        amountToDeposit
-      };
+      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;
     }
   }
-  throw new Error("Failed to build repay with collateral flashloan tx");
+  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,
@@ -47103,18 +47561,18 @@ async function buildRepayWithCollatFlashloanTx({
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   const cuRequestIxs = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
+  let amountToRepay;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
   if (repayOpts.repayBank.mint.equals(withdrawOpts.withdrawBank.mint)) {
-    swapResult.push({
-      amountToRepay: withdrawOpts.withdrawAmount,
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+    amountToRepay = withdrawOpts.withdrawAmount;
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
       new web3_js.PublicKey(repayOpts.repayBank.mint),
@@ -47122,41 +47580,50 @@ async function buildRepayWithCollatFlashloanTx({
       true,
       repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const swapResponse = await getJupiterSwapIxsForFlashloan({
-      quoteParams: {
-        inputMint: withdrawOpts.withdrawBank.mint.toBase58(),
-        outputMint: repayOpts.repayBank.mint.toBase58(),
-        amount: uiToNative(
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ).toNumber(),
-        dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-        slippageBps: swapOpts.jupiterOptions?.slippageBps ?? void 0,
-        swapMode: "ExactIn",
-        platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps ?? void 0,
-        onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
+    const swapConstraints = await computeFlashloanSwapConstraints({
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+      primaryIx: {
+        type: "withdraw",
+        bank: withdrawOpts.withdrawBank,
+        tokenProgram: withdrawOpts.tokenProgram
+      },
+      secondaryIx: {
+        type: "repay",
+        bank: repayOpts.repayBank,
+        tokenProgram: repayOpts.tokenProgram
       },
+      overrideInferAccounts
+    });
+    const swapResponse = await getSwapIxsForFlashloan({
+      inputMint: withdrawOpts.withdrawBank.mint.toBase58(),
+      outputMint: repayOpts.repayBank.mint.toBase58(),
+      amount: uiToNative(
+        withdrawOpts.withdrawAmount,
+        withdrawOpts.withdrawBank.mintDecimals
+      ).toNumber(),
+      swapMode: "ExactIn",
       authority: marginfiAccount.authority,
       connection,
       destinationTokenAccount,
-      configParams: swapOpts.jupiterOptions?.configParams
-    });
-    swapResponse.forEach((response) => {
-      const { swapInstruction, addressLookupTableAddresses, quoteResponse } = response;
-      const outAmount = nativeToUi(quoteResponse.outAmount, repayOpts.repayBank.mintDecimals);
-      const outAmountThreshold = nativeToUi(
-        quoteResponse.otherAmountThreshold,
-        repayOpts.repayBank.mintDecimals
-      );
-      const amountToRepay = outAmount > repayOpts.totalPositionAmount ? repayOpts.totalPositionAmount : outAmountThreshold;
-      swapResult.push({
-        amountToRepay,
-        swapInstructions: [swapInstruction],
-        setupInstructions: [],
-        swapLookupTables: addressLookupTableAddresses,
-        quoteResponse
-      });
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
+    sizeConstraintUsed = swapConstraints.sizeConstraint;
+    const { quoteResponse } = swapResponse;
+    const outAmount = nativeToUi(quoteResponse.outAmount, repayOpts.repayBank.mintDecimals);
+    const outAmountThreshold = nativeToUi(
+      quoteResponse.otherAmountThreshold,
+      repayOpts.repayBank.mintDecimals
+    );
+    amountToRepay = outAmount > repayOpts.totalPositionAmount ? repayOpts.totalPositionAmount : outAmountThreshold;
+    swapInstructions = swapResponse.swapInstructions;
+    swapLookupTables = swapResponse.addressLookupTableAddresses;
+    swapQuote = quoteResponse;
   }
   let withdrawIxs;
   switch (withdrawOpts.withdrawBank.config.assetTag) {
@@ -47294,68 +47761,70 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
   }
-  for (const [index, item] of swapResult.entries()) {
-    const { amountToRepay, swapInstructions, setupInstructions, swapLookupTables, quoteResponse } = item;
-    const repayIxs = await makeRepayIx3({
-      program,
-      bank: repayOpts.repayBank,
-      tokenProgram: repayOpts.tokenProgram,
-      amount: amountToRepay,
-      accountAddress: marginfiAccount.address,
-      authority: marginfiAccount.authority,
-      repayAll: isWholePosition(
-        {
-          amount: repayOpts.totalPositionAmount,
-          isLending: true
-        },
-        amountToRepay,
-        repayOpts.repayBank.mintDecimals
-      ),
-      isSync: false,
-      opts: {
-        wrapAndUnwrapSol: false,
-        overrideInferAccounts
-      }
-    });
-    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-    const flashloanParams = {
-      program,
-      marginfiAccount,
-      bankMap,
-      addressLookupTableAccounts: luts,
-      blockhash
-    };
-    const flashloanTx = await makeFlashLoanTx({
-      ...flashloanParams,
-      ixs: [
-        ...cuRequestIxs,
-        ...withdrawIxs.instructions,
-        ...swapInstructions,
-        ...repayIxs.instructions
-      ],
-      isSync: true
-    });
-    const txSize = getTxSize(flashloanTx);
-    const keySize = getAccountKeys(flashloanTx, luts);
-    const isLast = index === swapResult.length - 1;
-    if (txSize > MAX_TX_SIZE || keySize > 64) {
-      if (isLast) {
-        throw TransactionBuildingError.jupiterSwapSizeExceededRepay(txSize, keySize);
-      } else {
-        continue;
-      }
-    } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        withdrawIxs,
-        repayIxs,
-        amountToRepay
-      };
+  const repayIxs = await makeRepayIx3({
+    program,
+    bank: repayOpts.repayBank,
+    tokenProgram: repayOpts.tokenProgram,
+    amount: amountToRepay,
+    accountAddress: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    repayAll: isWholePosition(
+      {
+        amount: repayOpts.totalPositionAmount,
+        isLending: true
+      },
+      amountToRepay,
+      repayOpts.repayBank.mintDecimals
+    ),
+    isSync: false,
+    opts: {
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
     }
+  });
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    ...swapInstructions,
+    ...repayIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint: sizeConstraintUsed,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
   }
-  throw new Error("Failed to build repay with collateral flashloan tx");
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: true
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededRepay(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    repayIxs,
+    amountToRepay
+  };
 }
 
 // src/services/account/actions/emissions.ts
@@ -47509,11 +47978,16 @@ async function buildSwapCollateralFlashloanTx({
     actualWithdrawAmount,
     withdrawBank.mintDecimals
   );
-  const swapResult = [];
   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;
   let withdrawIxs;
   switch (withdrawOpts.withdrawBank.config.assetTag) {
     case 3 /* KAMINO */: {
@@ -47623,12 +48097,7 @@ async function buildSwapCollateralFlashloanTx({
     }
   }
   if (depositBank.mint.equals(withdrawBank.mint)) {
-    swapResult.push({
-      amountToDeposit: actualWithdrawAmount,
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+    amountToDeposit = actualWithdrawAmount;
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
       depositBank.mint,
@@ -47636,175 +48105,168 @@ async function buildSwapCollateralFlashloanTx({
       true,
       depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const swapResponses = await getJupiterSwapIxsForFlashloan({
-      quoteParams: {
-        inputMint: withdrawBank.mint.toBase58(),
-        outputMint: depositBank.mint.toBase58(),
-        amount: uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toNumber(),
-        dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-        slippageBps: swapOpts.jupiterOptions?.slippageBps,
-        swapMode: "ExactIn",
-        platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps,
-        onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
-      },
+    const swapConstraints = await computeFlashloanSwapConstraints({
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+      primaryIx: { type: "withdraw", bank: withdrawBank, tokenProgram: withdrawTokenProgram },
+      secondaryIx: { type: "deposit", bank: depositBank, tokenProgram: depositTokenProgram },
+      overrideInferAccounts
+    });
+    const swapResponses = await getSwapIxsForFlashloan({
+      inputMint: withdrawBank.mint.toBase58(),
+      outputMint: depositBank.mint.toBase58(),
+      amount: uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toNumber(),
+      swapMode: "ExactIn",
       authority: marginfiAccount.authority,
       connection,
       destinationTokenAccount,
-      configParams: swapOpts.jupiterOptions?.configParams
-    });
-    swapResponses.forEach((response) => {
-      const outAmountThreshold = nativeToUi(
-        response.quoteResponse.otherAmountThreshold,
-        depositBank.mintDecimals
-      );
-      swapResult.push({
-        amountToDeposit: outAmountThreshold,
-        swapInstructions: [response.swapInstruction],
-        setupInstructions: response.setupInstructions,
-        swapLookupTables: response.addressLookupTableAddresses,
-        quoteResponse: response.quoteResponse
-      });
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
-  }
-  if (swapResult.length === 0) {
-    throw new Error(
-      `No swap routes found for ${withdrawBank.mint.toBase58()} -> ${depositBank.mint.toBase58()}`
+    sizeConstraintUsed = swapConstraints.sizeConstraint;
+    amountToDeposit = nativeToUi(
+      swapResponses.quoteResponse.otherAmountThreshold,
+      depositBank.mintDecimals
     );
+    swapInstructions = swapResponses.swapInstructions;
+    setupInstructions = swapResponses.setupInstructions;
+    swapLookupTables = swapResponses.addressLookupTableAddresses;
+    swapQuote = swapResponses.quoteResponse;
   }
-  for (const [index, item] of swapResult.entries()) {
-    const {
-      amountToDeposit,
-      swapInstructions,
-      setupInstructions,
-      swapLookupTables,
-      quoteResponse
-    } = item;
-    let depositIxs;
-    switch (depositBank.config.assetTag) {
-      case 3 /* KAMINO */: {
-        const reserve = bankMetadataMap[depositBank.address.toBase58()]?.kaminoStates?.reserveState;
-        if (!reserve) {
-          throw TransactionBuildingError.kaminoReserveNotFound(
-            depositBank.address.toBase58(),
-            depositBank.mint.toBase58(),
-            depositBank.tokenSymbol
-          );
-        }
-        depositIxs = await makeKaminoDepositIx3({
-          program,
-          bank: depositBank,
-          tokenProgram: depositTokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          reserve,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
+  let depositIxs;
+  switch (depositBank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[depositBank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          depositBank.address.toBase58(),
+          depositBank.mint.toBase58(),
+          depositBank.tokenSymbol
+        );
       }
-      case 4 /* DRIFT */: {
-        const driftState = bankMetadataMap[depositBank.address.toBase58()]?.driftStates;
-        if (!driftState) {
-          throw TransactionBuildingError.driftStateNotFound(
-            depositBank.address.toBase58(),
-            depositBank.mint.toBase58(),
-            depositBank.tokenSymbol
-          );
+      depositIxs = await makeKaminoDepositIx3({
+        program,
+        bank: depositBank,
+        tokenProgram: depositTokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
         }
-        const driftMarketIndex = driftState.spotMarketState.marketIndex;
-        const driftOracle = driftState.spotMarketState.oracle;
-        depositIxs = await makeDriftDepositIx3({
-          program,
-          bank: depositBank,
-          tokenProgram: depositTokenProgram,
-          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: depositBank,
-          tokenProgram: depositTokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
-      }
-      default: {
-        depositIxs = await makeDepositIx3({
-          program,
-          bank: depositBank,
-          tokenProgram: depositTokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
-      }
+      });
+      break;
     }
-    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-    const flashloanParams = {
-      program,
-      marginfiAccount,
-      bankMap,
-      addressLookupTableAccounts: luts,
-      blockhash
-    };
-    const flashloanTx = await makeFlashLoanTx({
-      ...flashloanParams,
-      ixs: [
-        ...cuRequestIxs,
-        ...withdrawIxs.instructions,
-        ...swapInstructions,
-        ...depositIxs.instructions
-      ],
-      isSync: true
-    });
-    const txSize = getTxSize(flashloanTx);
-    const keySize = getAccountKeys(flashloanTx, luts);
-    const isLast = index === swapResult.length - 1;
-    if (txSize > MAX_TX_SIZE || keySize > 64) {
-      if (isLast) {
-        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
-      } else {
-        continue;
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[depositBank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          depositBank.address.toBase58(),
+          depositBank.mint.toBase58(),
+          depositBank.tokenSymbol
+        );
       }
-    } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        withdrawIxs,
-        depositIxs
-      };
+      const driftMarketIndex = driftState.spotMarketState.marketIndex;
+      const driftOracle = driftState.spotMarketState.oracle;
+      depositIxs = await makeDriftDepositIx3({
+        program,
+        bank: depositBank,
+        tokenProgram: depositTokenProgram,
+        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: depositBank,
+        tokenProgram: depositTokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
     }
+    default: {
+      depositIxs = await makeDepositIx3({
+        program,
+        bank: depositBank,
+        tokenProgram: depositTokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+  }
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    ...swapInstructions,
+    ...depositIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint: sizeConstraintUsed,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
   }
-  throw new Error("Failed to build swap collateral flashloan tx");
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: true
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    depositIxs
+  };
 }
 async function makeSwapDebtTx(params) {
   const {
@@ -47942,7 +48404,6 @@ async function buildSwapDebtFlashloanTx({
     throw new Error("repayAmount must be greater than 0");
   }
   const actualRepayAmount = Math.min(repayAmount ?? totalPositionAmount, totalPositionAmount);
-  const swapResult = [];
   const cuRequestIxs = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
@@ -47953,313 +48414,120 @@ async function buildSwapDebtFlashloanTx({
     true,
     repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
   );
-  const jupiterApiClient = swapOpts.jupiterOptions?.configParams?.basePath ? new api.SwapApi(new api.Configuration(swapOpts.jupiterOptions.configParams)) : api.createJupiterApiClient(swapOpts.jupiterOptions?.configParams);
-  const estimateQuote = await jupiterApiClient.quoteGet({
+  const { otherAmountThreshold } = await getExactOutEstimate({
     inputMint: borrowBank.mint.toBase58(),
     outputMint: repayBank.mint.toBase58(),
     amount: uiToNative(actualRepayAmount, repayBank.mintDecimals).toNumber(),
-    swapMode: "ExactOut",
-    dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-    slippageBps: swapOpts.jupiterOptions?.slippageBps
+    swapOpts,
+    connection
   });
-  const estimatedBorrowAmount = nativeToUi(
-    estimateQuote.otherAmountThreshold,
-    borrowBank.mintDecimals
-  );
-  const swapResponses = await getJupiterSwapIxsForFlashloan({
-    quoteParams: {
-      inputMint: borrowBank.mint.toBase58(),
-      outputMint: repayBank.mint.toBase58(),
-      amount: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
-      dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-      slippageBps: swapOpts.jupiterOptions?.slippageBps,
-      swapMode: "ExactIn",
-      platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps,
-      onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
-    },
+  const estimatedBorrowAmount = nativeToUi(otherAmountThreshold, borrowBank.mintDecimals);
+  const swapConstraints = await computeFlashloanSwapConstraints({
+    program,
+    marginfiAccount,
+    bankMap,
+    bankMetadataMap,
+    addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+    primaryIx: { type: "borrow", bank: borrowBank, tokenProgram: borrowTokenProgram },
+    secondaryIx: { type: "repay", bank: repayBank, tokenProgram: repayTokenProgram },
+    overrideInferAccounts
+  });
+  const swapResponses = await getSwapIxsForFlashloan({
+    inputMint: borrowBank.mint.toBase58(),
+    outputMint: repayBank.mint.toBase58(),
+    amount: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
+    swapMode: "ExactIn",
     authority: marginfiAccount.authority,
     connection,
     destinationTokenAccount,
-    configParams: swapOpts.jupiterOptions?.configParams
+    swapOpts,
+    sizeConstraint: swapConstraints.sizeConstraint,
+    maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
   });
-  swapResponses.forEach((response) => {
-    const outAmount = nativeToUi(response.quoteResponse.outAmount, repayBank.mintDecimals);
-    const outAmountThreshold = nativeToUi(
-      response.quoteResponse.otherAmountThreshold,
-      repayBank.mintDecimals
-    );
-    const amountToRepay = outAmount > totalPositionAmount ? totalPositionAmount : outAmountThreshold;
-    const borrowAmount = nativeToUi(response.quoteResponse.inAmount, borrowBank.mintDecimals);
-    swapResult.push({
-      amountToRepay,
-      borrowAmount,
-      swapInstructions: [response.swapInstruction],
-      setupInstructions: response.setupInstructions,
-      swapLookupTables: response.addressLookupTableAddresses,
-      quoteResponse: response.quoteResponse
-    });
+  const { quoteResponse } = swapResponses;
+  const outAmount = nativeToUi(quoteResponse.outAmount, repayBank.mintDecimals);
+  const outAmountThreshold = nativeToUi(quoteResponse.otherAmountThreshold, repayBank.mintDecimals);
+  const amountToRepay = outAmount > totalPositionAmount ? totalPositionAmount : outAmountThreshold;
+  const borrowAmount = nativeToUi(quoteResponse.inAmount, borrowBank.mintDecimals);
+  const borrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowBank,
+    bankMap,
+    tokenProgram: borrowTokenProgram,
+    amount: borrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: true,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
   });
-  if (swapResult.length === 0) {
-    throw new Error(
-      `No swap routes found for ${borrowBank.mint.toBase58()} -> ${repayBank.mint.toBase58()}`
-    );
-  }
-  for (const [index, item] of swapResult.entries()) {
-    const {
+  const repayIxs = await makeRepayIx3({
+    program,
+    bank: repayBank,
+    tokenProgram: repayTokenProgram,
+    amount: amountToRepay,
+    accountAddress: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    repayAll: isWholePosition(
+      {
+        amount: totalPositionAmount,
+        isLending: false
+      },
       amountToRepay,
-      borrowAmount,
-      swapInstructions,
-      setupInstructions,
-      swapLookupTables,
-      quoteResponse
-    } = item;
-    const borrowIxs = await makeBorrowIx3({
-      program,
-      bank: borrowBank,
-      bankMap,
-      tokenProgram: borrowTokenProgram,
-      amount: borrowAmount,
-      marginfiAccount,
-      authority: marginfiAccount.authority,
-      isSync: true,
-      opts: {
-        createAtas: false,
-        wrapAndUnwrapSol: false,
-        overrideInferAccounts
-      }
-    });
-    const repayIxs = await makeRepayIx3({
-      program,
-      bank: repayBank,
-      tokenProgram: repayTokenProgram,
-      amount: amountToRepay,
-      accountAddress: marginfiAccount.address,
-      authority: marginfiAccount.authority,
-      repayAll: isWholePosition(
-        {
-          amount: totalPositionAmount,
-          isLending: false
-        },
-        amountToRepay,
-        repayBank.mintDecimals
-      ),
-      isSync: true,
-      opts: {
-        wrapAndUnwrapSol: false,
-        overrideInferAccounts
-      }
-    });
-    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-    const flashloanParams = {
-      program,
-      marginfiAccount,
-      bankMap,
-      addressLookupTableAccounts: luts,
-      blockhash
-    };
-    const flashloanTx = await makeFlashLoanTx({
-      ...flashloanParams,
-      ixs: [
-        ...cuRequestIxs,
-        ...borrowIxs.instructions,
-        ...swapInstructions,
-        ...repayIxs.instructions
-      ],
-      isSync: true
-    });
-    const txSize = getTxSize(flashloanTx);
-    const keySize = getAccountKeys(flashloanTx, luts);
-    const isLast = index === swapResult.length - 1;
-    if (txSize > MAX_TX_SIZE || keySize > 64) {
-      if (isLast) {
-        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
-      } else {
-        continue;
-      }
-    } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        borrowIxs,
-        repayIxs
-      };
-    }
-  }
-  throw new Error("Failed to build swap debt flashloan tx");
-}
-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
-      }));
+      repayBank.mintDecimals
+    ),
+    isSync: true,
+    opts: {
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
     }
   });
-  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,
+  const luts = [
+    ...addressLookupTableAccounts ?? [],
+    ...swapResponses.addressLookupTableAddresses
+  ];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...swapResponses.swapInstructions,
+    ...repayIxs.instructions
+  ];
+  compileFlashloanPrecheck({
+    allIxs: allNonFlIxs,
+    payer: marginfiAccount.authority,
     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 */
+    sizeConstraint: swapConstraints.sizeConstraint,
+    swapIxCount: swapResponses.swapInstructions.length,
+    swapLutCount: swapResponses.addressLookupTableAddresses.length
+  });
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: true
   });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions: swapResponses.setupInstructions,
+    swapQuote: quoteResponse,
+    borrowIxs,
+    repayIxs
+  };
 }
 
 // src/services/account/services/account-simulation.service.ts
@@ -48885,17 +49153,528 @@ function computeMaxWithdrawForBank(params) {
   const maxWithdraw = initUntiedCollateralForBank.div(initWeightedPrice);
   return maxWithdraw;
 }
+var TITAN_FEE_WALLET = new web3_js.PublicKey("6ryqDDCwKFZfSiHQrYRkjTEarbsLjg9TmuFg1RJorBk3");
+var getTitanFeeAccount = (mint) => {
+  return getAssociatedTokenAddressSync(mint, TITAN_FEE_WALLET, true);
+};
+var checkTitanFeeAccount = async (connection, mint) => {
+  const feeAccount = getTitanFeeAccount(mint);
+  const hasFeeAccount = !!await connection.getAccountInfo(feeAccount);
+  return { feeAccount, hasFeeAccount, feeWallet: TITAN_FEE_WALLET };
+};
+function deserializeTitanInstruction(ix) {
+  return new web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(ix.p),
+    keys: ix.a.map((account) => ({
+      pubkey: new web3_js.PublicKey(account.p),
+      isSigner: account.s,
+      isWritable: account.w
+    })),
+    data: Buffer.from(ix.d)
+  });
+}
+var getTitanSwapIxsForFlashloan = async ({
+  quoteParams,
+  authority,
+  connection,
+  destinationTokenAccount,
+  apiConfig
+}) => {
+  const basePath = apiConfig?.basePath ?? "";
+  const feeMint = new web3_js.PublicKey(
+    quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint
+  );
+  const { feeAccount, hasFeeAccount } = await checkTitanFeeAccount(connection, feeMint);
+  let finalQuoteParams = quoteParams;
+  if (!hasFeeAccount) {
+    console.warn("Warning: Titan fee account ATA does not exist, disabling platform fee");
+    finalQuoteParams = {
+      ...quoteParams,
+      platformFeeBps: void 0
+    };
+  }
+  if (basePath.startsWith("wss://") || basePath.startsWith("ws://")) {
+    return getTitanSwapIxsViaWebSocket(
+      { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
+      hasFeeAccount ? feeAccount : void 0
+    );
+  } else {
+    return getTitanSwapIxsViaHttpProxy(
+      { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
+      hasFeeAccount ? feeAccount : void 0
+    );
+  }
+};
+async function getTitanSwapIxsViaWebSocket(params, feeAccount) {
+  const { quoteParams, authority, connection, destinationTokenAccount, apiConfig } = params;
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    slippageBps,
+    platformFeeBps,
+    directRoutesOnly,
+    sizeConstraint,
+    maxSwapAccounts,
+    maxSwapTotalAccounts
+  } = quoteParams;
+  const wsUrl = apiConfig?.basePath;
+  if (!wsUrl) {
+    throw new Error("Titan WebSocket URL is required (apiConfig.basePath)");
+  }
+  const txParams = {
+    userPublicKey: authority.toBytes(),
+    outputAccount: destinationTokenAccount.toBytes()
+  };
+  if (feeAccount && platformFeeBps) {
+    txParams.feeBps = platformFeeBps;
+    txParams.feeAccount = feeAccount.toBytes();
+  }
+  const client = await V1Client.connect(wsUrl);
+  try {
+    const { stream } = await client.newSwapQuoteStream({
+      swap: {
+        inputMint: new web3_js.PublicKey(inputMint).toBytes(),
+        outputMint: new web3_js.PublicKey(outputMint).toBytes(),
+        amount,
+        swapMode,
+        slippageBps,
+        onlyDirectRoutes: directRoutesOnly,
+        addSizeConstraint: sizeConstraint !== void 0,
+        sizeConstraint,
+        accountsLimitWritable: maxSwapAccounts,
+        accountsLimitTotal: maxSwapTotalAccounts
+      },
+      transaction: txParams,
+      update: {
+        num_quotes: 3
+      }
+    });
+    const reader = stream.getReader();
+    const { value: swapQuotes, done } = await reader.read();
+    reader.releaseLock();
+    if (done || !swapQuotes) {
+      throw new Error("Titan swap quote stream ended without data");
+    }
+    const quotes = swapQuotes;
+    const bestRoute = selectBestRoute(quotes.quotes, swapMode);
+    if (!bestRoute) {
+      throw new Error(`No Titan swap routes found for ${inputMint} -> ${outputMint}`);
+    }
+    const swapInstructions = bestRoute.instructions.map(deserializeTitanInstruction);
+    const lutPubkeys = bestRoute.addressLookupTables.map((lutBytes) => new web3_js.PublicKey(lutBytes));
+    const addressLookupTableAddresses = await resolveLookupTables(connection, lutPubkeys);
+    const quoteResponse = {
+      ...buildSwapQuoteResult(bestRoute, swapMode),
+      provider: "TITAN" /* TITAN */
+    };
+    return {
+      swapInstructions,
+      setupInstructions: [],
+      addressLookupTableAddresses,
+      quoteResponse
+    };
+  } finally {
+    if (!client.closed) {
+      await client.close();
+    }
+  }
+}
+async function getTitanSwapIxsViaHttpProxy(params, feeAccount) {
+  const { quoteParams, authority, connection, destinationTokenAccount, apiConfig } = params;
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    slippageBps,
+    platformFeeBps,
+    directRoutesOnly,
+    sizeConstraint,
+    maxSwapAccounts,
+    maxSwapTotalAccounts
+  } = quoteParams;
+  const basePath = apiConfig?.basePath;
+  if (!basePath) {
+    throw new Error("Titan proxy URL is required (apiConfig.basePath)");
+  }
+  const txBody = {
+    userPublicKey: authority.toBase58(),
+    outputAccount: destinationTokenAccount.toBase58()
+  };
+  if (feeAccount && platformFeeBps) {
+    txBody.feeBps = platformFeeBps;
+    txBody.feeAccount = feeAccount.toBase58();
+  }
+  const response = await fetch(`${basePath}/swap-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiConfig?.headers ?? {}
+    },
+    body: JSON.stringify({
+      swap: {
+        inputMint,
+        outputMint,
+        amount,
+        swapMode,
+        slippageBps,
+        onlyDirectRoutes: directRoutesOnly,
+        addSizeConstraint: sizeConstraint !== void 0,
+        sizeConstraint,
+        accountsLimitWritable: maxSwapAccounts,
+        accountsLimitTotal: maxSwapTotalAccounts
+      },
+      transaction: txBody
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(
+      `Titan proxy error (${response.status}): ${errorData.message ?? response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const bestRoute = selectBestRoute(data.quotes, swapMode);
+  if (!bestRoute) {
+    throw new Error(`No Titan swap routes found for ${inputMint} -> ${outputMint}`);
+  }
+  const swapInstructions = bestRoute.instructions.map(deserializeSerializedInstruction);
+  const lutPubkeys = bestRoute.addressLookupTables.map(
+    (b64) => new web3_js.PublicKey(Buffer.from(b64, "base64"))
+  );
+  const addressLookupTableAddresses = await resolveLookupTables(connection, lutPubkeys);
+  const quoteResponse = {
+    ...buildSwapQuoteResult(bestRoute, swapMode),
+    provider: "TITAN" /* TITAN */
+  };
+  return {
+    swapInstructions,
+    setupInstructions: [],
+    addressLookupTableAddresses,
+    quoteResponse
+  };
+}
+var getTitanExactOutEstimate = async (params) => {
+  const basePath = params.apiConfig?.basePath ?? "";
+  if (basePath.startsWith("wss://") || basePath.startsWith("ws://")) {
+    return getTitanExactOutViaWebSocket(params);
+  } else {
+    return getTitanExactOutViaHttpProxy(params);
+  }
+};
+async function getTitanExactOutViaWebSocket(params) {
+  const { inputMint, outputMint, amount, slippageBps, apiConfig } = params;
+  const wsUrl = apiConfig?.basePath;
+  if (!wsUrl) {
+    throw new Error("Titan WebSocket URL is required (apiConfig.basePath)");
+  }
+  const client = await V1Client.connect(wsUrl);
+  try {
+    const { stream } = await client.newSwapQuoteStream({
+      swap: {
+        inputMint: new web3_js.PublicKey(inputMint).toBytes(),
+        outputMint: new web3_js.PublicKey(outputMint).toBytes(),
+        amount,
+        swapMode: "ExactOut" /* ExactOut */,
+        slippageBps
+      },
+      transaction: {
+        userPublicKey: new Uint8Array(32)
+        // placeholder, not executing
+      },
+      update: {
+        num_quotes: 1
+      }
+    });
+    const reader = stream.getReader();
+    const { value: swapQuotes, done } = await reader.read();
+    reader.releaseLock();
+    if (done || !swapQuotes) {
+      throw new Error("Titan ExactOut estimate stream ended without data");
+    }
+    const quotes = swapQuotes;
+    const bestRoute = selectBestRoute(quotes.quotes, "ExactOut");
+    if (!bestRoute) {
+      throw new Error(`No Titan ExactOut routes found for ${inputMint} -> ${outputMint}`);
+    }
+    const quoteResult = {
+      ...buildSwapQuoteResult(bestRoute, "ExactOut"),
+      provider: "TITAN" /* TITAN */
+    };
+    return {
+      otherAmountThreshold: quoteResult.otherAmountThreshold,
+      quoteResult
+    };
+  } finally {
+    if (!client.closed) {
+      await client.close();
+    }
+  }
+}
+async function getTitanExactOutViaHttpProxy(params) {
+  const { inputMint, outputMint, amount, slippageBps, apiConfig } = params;
+  const basePath = apiConfig?.basePath;
+  if (!basePath) {
+    throw new Error("Titan proxy URL is required (apiConfig.basePath)");
+  }
+  const response = await fetch(`${basePath}/exact-out-estimate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiConfig?.headers ?? {}
+    },
+    body: JSON.stringify({
+      inputMint,
+      outputMint,
+      amount,
+      slippageBps
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(
+      `Titan proxy error (${response.status}): ${errorData.message ?? response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const quoteResult = {
+    inAmount: String(data.inAmount),
+    outAmount: String(data.outAmount),
+    otherAmountThreshold: data.otherAmountThreshold,
+    slippageBps: data.slippageBps,
+    provider: "TITAN" /* TITAN */
+  };
+  return {
+    otherAmountThreshold: data.otherAmountThreshold,
+    quoteResult
+  };
+}
+
+// src/services/account/utils/swap.utils.ts
+function getSwapProviderFn({
+  attemptProvider,
+  maxSwapTotalAccounts,
+  inputMint,
+  outputMint,
+  amount,
+  swapMode,
+  authority,
+  connection,
+  destinationTokenAccount,
+  swapOpts,
+  sizeConstraint
+}) {
+  switch (attemptProvider) {
+    case "TITAN" /* TITAN */:
+      return (apiConfig) => getTitanSwapIxsForFlashloan({
+        quoteParams: {
+          inputMint,
+          outputMint,
+          amount,
+          swapMode,
+          slippageBps: swapOpts.swapConfig?.slippageBps,
+          platformFeeBps: swapOpts.swapConfig?.platformFeeBps,
+          directRoutesOnly: swapOpts.swapConfig?.directRoutesOnly,
+          sizeConstraint,
+          maxSwapTotalAccounts
+        },
+        authority,
+        connection,
+        destinationTokenAccount,
+        apiConfig
+      });
+    case "JUPITER" /* JUPITER */:
+      return (apiConfig) => getJupiterSwapIxsForFlashloan({
+        quoteParams: {
+          inputMint,
+          outputMint,
+          amount,
+          swapMode,
+          dynamicSlippage: swapOpts.swapConfig ? swapOpts.swapConfig.slippageMode === "DYNAMIC" : true,
+          slippageBps: swapOpts.swapConfig?.slippageBps,
+          platformFeeBps: swapOpts.swapConfig?.platformFeeBps,
+          onlyDirectRoutes: swapOpts.swapConfig?.directRoutesOnly ?? false
+        },
+        authority,
+        connection,
+        destinationTokenAccount,
+        apiConfig,
+        maxSwapAccounts: maxSwapTotalAccounts
+      });
+    default:
+      return void 0;
+  }
+}
+function getExactOutProviderFn({
+  attemptProvider,
+  inputMint,
+  outputMint,
+  amount,
+  swapOpts,
+  apiConfig
+}) {
+  switch (attemptProvider) {
+    case "TITAN" /* TITAN */:
+      return () => getTitanExactOutEstimate({
+        inputMint,
+        outputMint,
+        amount,
+        slippageBps: swapOpts.swapConfig?.slippageBps,
+        apiConfig
+      });
+    case "JUPITER" /* JUPITER */:
+      return async () => {
+        const configParams = toJupiterConfig(apiConfig);
+        const jupiterApiClient = configParams?.basePath ? new api.SwapApi(new api.Configuration(configParams)) : api.createJupiterApiClient(configParams);
+        const estimateQuote = await jupiterApiClient.quoteGet({
+          inputMint,
+          outputMint,
+          amount,
+          swapMode: "ExactOut",
+          dynamicSlippage: swapOpts.swapConfig ? swapOpts.swapConfig.slippageMode === "DYNAMIC" : true,
+          slippageBps: swapOpts.swapConfig?.slippageBps
+        });
+        const quoteResult = mapJupiterQuoteToSwapQuoteResult(estimateQuote);
+        return { otherAmountThreshold: quoteResult.otherAmountThreshold, quoteResult };
+      };
+    default:
+      return void 0;
+  }
+}
+var getSwapIxsForFlashloan = async (params) => {
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    authority,
+    connection,
+    destinationTokenAccount,
+    swapOpts,
+    sizeConstraint,
+    maxSwapTotalAccounts
+  } = params;
+  if (swapOpts.swapIxs) {
+    return {
+      swapInstructions: swapOpts.swapIxs.instructions,
+      setupInstructions: [],
+      addressLookupTableAddresses: swapOpts.swapIxs.lookupTables,
+      quoteResponse: {
+        inAmount: String(amount),
+        outAmount: "0",
+        otherAmountThreshold: "0",
+        slippageBps: 0
+      }
+    };
+  }
+  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
+  const attempts = [
+    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
+    ...swapOpts.swapConfig?.fallbackProviders ?? []
+  ];
+  let lastError;
+  for (const { provider: attemptProvider, apiConfig } of attempts) {
+    const fn = getSwapProviderFn({
+      attemptProvider,
+      maxSwapTotalAccounts: params.maxSwapTotalAccounts,
+      inputMint,
+      outputMint,
+      amount,
+      swapMode,
+      authority,
+      connection,
+      destinationTokenAccount,
+      swapOpts,
+      sizeConstraint
+    });
+    if (!fn) continue;
+    try {
+      return await fn(apiConfig);
+    } catch (err) {
+      if (err instanceof TransactionBuildingError) throw err;
+      lastError = err;
+      console.warn(`[swap] ${attemptProvider} failed:`, err instanceof Error ? err.message : err);
+    }
+  }
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+var getExactOutEstimate = async (params) => {
+  const { inputMint, outputMint, amount, swapOpts, connection } = params;
+  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
+  const attempts = [
+    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
+    ...swapOpts.swapConfig?.fallbackProviders ?? []
+  ];
+  let lastError;
+  for (const { provider: attemptProvider, apiConfig } of attempts) {
+    const fn = getExactOutProviderFn({
+      attemptProvider,
+      inputMint,
+      outputMint,
+      amount,
+      swapOpts,
+      apiConfig
+    });
+    if (!fn) continue;
+    try {
+      return await fn(apiConfig);
+    } catch (err) {
+      if (err instanceof TransactionBuildingError) throw err;
+      lastError = err;
+      console.warn(
+        `[exactout] ${attemptProvider} failed:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+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 referralProgramPubkey = REFERRAL_PROGRAM_ID;
-  const referralAccountPubkey = REFERRAL_ACCOUNT_PUBKEY;
   const [feeAccount] = web3_js.PublicKey.findProgramAddressSync(
-    [Buffer.from("referral_ata"), referralAccountPubkey.toBuffer(), mint.toBuffer()],
-    referralProgramPubkey
+    [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),
@@ -48907,17 +49686,26 @@ function deserializeJupiterInstruction(instruction) {
     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,
-  configParams
+  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 = getFeeAccount(new web3_js.PublicKey(feeMint));
-  const hasFeeAccount = !!await connection.getAccountInfo(new web3_js.PublicKey(feeAccount));
+  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) {
@@ -48927,67 +49715,45 @@ var getJupiterSwapIxsForFlashloan = async ({
       platformFeeBps: void 0
     };
   }
-  const maxAccountsArr = [40, 30];
-  const swapQuotes = await Promise.all(
-    maxAccountsArr.map((maxAccounts) => {
-      return jupiterApiClient.quoteGet({
-        ...finalQuoteParams,
-        maxAccounts
-      });
-    })
-  );
-  hasFeeAccount && finalQuoteParams.platformFeeBps && finalQuoteParams.platformFeeBps > 0;
-  const swapInstructionResponses = await Promise.all(
-    swapQuotes.map(
-      (quote) => jupiterApiClient.swapInstructionsPost({
-        swapRequest: {
-          quoteResponse: quote,
-          userPublicKey: authority.toBase58(),
-          feeAccount: hasFeeAccount ? feeAccount : void 0,
-          wrapAndUnwrapSol: false,
-          destinationTokenAccount: destinationTokenAccount.toBase58()
-        }
-      })
-    )
-  );
-  const lutAddresses = swapInstructionResponses.map(
-    (swapInstructionResponse) => swapInstructionResponse.addressLookupTableAddresses
-  );
+  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.flat().map((address) => new web3_js.PublicKey(address))
+    lutAddresses.map((address) => new web3_js.PublicKey(address))
   );
-  let currentIndex = 0;
-  const jupiterSwapIxs = [];
-  for (let i = 0; i < swapInstructionResponses.length; i++) {
-    const response = swapInstructionResponses[i];
-    const quote = swapQuotes[i];
-    if (!response || !quote) continue;
-    const address = response.addressLookupTableAddresses;
-    const addressesLength = address.length;
-    const addressesStartIndex = currentIndex;
-    const addressesEndIndex = addressesStartIndex + addressesLength;
-    currentIndex = addressesEndIndex;
-    const lutAccounts = lutAccountsRaw.slice(addressesStartIndex, addressesEndIndex);
-    const addressLookupTableAccounts = lutAccounts.map((accountInfo, index) => {
-      const addressLookupTableAddress = address[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(response.swapInstruction);
-    const setupInstructions = response.setupInstructions.map(deserializeJupiterInstruction);
-    jupiterSwapIxs.push({
-      swapInstruction: instruction,
-      setupInstructions,
-      addressLookupTableAddresses: addressLookupTableAccounts,
-      quoteResponse: quote
+  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)
     });
-  }
-  return jupiterSwapIxs;
+  }).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
@@ -49005,6 +49771,440 @@ 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
+      });
+    }
+  }
+}
+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/price/utils/smart-crank.utils.ts
 async function computeSmartCrank({
@@ -50208,7 +51408,7 @@ function computeMaxLeverage(depositBank, borrowBank, opts) {
     ltv
   };
 }
-function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank, depositOracleInfo, borrowOracleInfo, opts) {
+function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank, depositPriceUsd, borrowPriceUsd, opts) {
   const initialCollateral = toBigNumber(principal);
   const { maxLeverage } = computeMaxLeverage(depositBank, borrowBank, opts);
   let clampedLeverage = targetLeverage;
@@ -50223,7 +51423,7 @@ function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank
   }
   const totalDepositAmount = initialCollateral.times(new BigNumber3__default.default(clampedLeverage));
   const additionalDepositAmount = totalDepositAmount.minus(initialCollateral);
-  const totalBorrowAmount = additionalDepositAmount.times(depositOracleInfo.priceWeighted.lowestPrice).div(borrowOracleInfo.priceWeighted.highestPrice);
+  const totalBorrowAmount = additionalDepositAmount.times(new BigNumber3__default.default(depositPriceUsd)).div(new BigNumber3__default.default(borrowPriceUsd));
   return {
     totalBorrowAmount: totalBorrowAmount.decimalPlaces(
       borrowBank.mintDecimals,
@@ -51267,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;
@@ -52690,7 +54114,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.depositOpts - Deposit configuration (bank, amount, mode)
    * @param params.borrowOpts - Borrow configuration (bank, amount)
-   * @param params.swapOpts - Jupiter swap configuration (slippage, fees)
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52728,7 +54152,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.withdrawOpts - Withdraw configuration (bank, amount)
    * @param params.repayOpts - Repay configuration (bank, optional amount)
-   * @param params.swapOpts - Jupiter swap configuration
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52768,7 +54192,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.withdrawOpts - Withdraw configuration (bank, amount, tokenProgram)
    * @param params.depositOpts - Deposit configuration (bank, tokenProgram)
-   * @param params.swapOpts - Jupiter swap configuration
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52808,7 +54232,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.repayOpts - Repay configuration (bank, amount, tokenProgram)
    * @param params.borrowOpts - Borrow configuration (bank, tokenProgram)
-   * @param params.swapOpts - Jupiter swap configuration
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -53703,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
   // ----------------------------------------------------------------------------
   /**
@@ -54032,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,
@@ -54156,6 +55475,7 @@ exports.MARGINFI_PROGRAM = MARGINFI_PROGRAM;
 exports.MARGINFI_PROGRAM_STAGING = MARGINFI_PROGRAM_STAGING;
 exports.MARGINFI_PROGRAM_STAGING_ALT = MARGINFI_PROGRAM_STAGING_ALT;
 exports.MARGINFI_SPONSORED_SHARD_ID = MARGINFI_SPONSORED_SHARD_ID;
+exports.MAX_ACCOUNT_LOCKS = MAX_ACCOUNT_LOCKS;
 exports.MAX_CONFIDENCE_INTERVAL_RATIO = MAX_CONFIDENCE_INTERVAL_RATIO;
 exports.MAX_TX_SIZE = MAX_TX_SIZE;
 exports.MAX_U64 = MAX_U64;
@@ -54191,6 +55511,7 @@ exports.SYSTEM_PROGRAM_ID = SYSTEM_PROGRAM_ID;
 exports.SYSVAR_CLOCK_ID = SYSVAR_CLOCK_ID;
 exports.SYSVAR_RENT_ID = SYSVAR_RENT_ID;
 exports.SYSVAR_STAKE_HISTORY_ID = SYSVAR_STAKE_HISTORY_ID;
+exports.SwapProvider = SwapProvider;
 exports.TRANSFER_ACCOUNT_AUTHORITY_FLAG = TRANSFER_ACCOUNT_AUTHORITY_FLAG;
 exports.TransactionArenaKeyMap = TransactionArenaKeyMap;
 exports.TransactionBuildingError = TransactionBuildingError;
@@ -54224,6 +55545,7 @@ exports.checkMultipleOraclesCrankability = checkMultipleOraclesCrankability;
 exports.chunkedGetRawMultipleAccountInfoOrdered = chunkedGetRawMultipleAccountInfoOrdered;
 exports.chunkedGetRawMultipleAccountInfoOrderedWithNulls = chunkedGetRawMultipleAccountInfoOrderedWithNulls;
 exports.chunkedGetRawMultipleAccountInfos = chunkedGetRawMultipleAccountInfos;
+exports.compileFlashloanPrecheck = compileFlashloanPrecheck;
 exports.composeRemainingAccounts = composeRemainingAccounts;
 exports.computeAccountValue = computeAccountValue;
 exports.computeActiveEmodePairs = computeActiveEmodePairs;
@@ -54234,6 +55556,8 @@ exports.computeBaseInterestRate = computeBaseInterestRate;
 exports.computeClaimedEmissions = computeClaimedEmissions;
 exports.computeClosePositionTokenAmount = computeClosePositionTokenAmount;
 exports.computeEmodeImpacts = computeEmodeImpacts;
+exports.computeFlashLoanNonSwapBudget = computeFlashLoanNonSwapBudget;
+exports.computeFlashloanSwapConstraints = computeFlashloanSwapConstraints;
 exports.computeFreeCollateralFromBalances = computeFreeCollateralFromBalances;
 exports.computeFreeCollateralFromCache = computeFreeCollateralFromCache;
 exports.computeHealthAccountMetas = computeHealthAccountMetas;
@@ -54258,10 +55582,12 @@ exports.computeQuantity = computeQuantity;
 exports.computeQuantityUi = computeQuantityUi;
 exports.computeRemainingCapacity = computeRemainingCapacity;
 exports.computeSmartCrank = computeSmartCrank;
+exports.computeStakedBankMultipliers = computeStakedBankMultipliers;
 exports.computeTotalOutstandingEmissions = computeTotalOutstandingEmissions;
 exports.computeTvl = computeTvl;
 exports.computeUsdValue = computeUsdValue;
 exports.computeUtilizationRate = computeUtilizationRate;
+exports.computeV0TxSize = computeV0TxSize;
 exports.convertVoteAccCoeffsToBankCoeffs = convertVoteAccCoeffsToBankCoeffs;
 exports.createActiveEmodePairFromPairs = createActiveEmodePairFromPairs;
 exports.createEmptyBalance = createEmptyBalance;
@@ -54337,6 +55663,7 @@ exports.getDriftCTokenMultiplier = getDriftCTokenMultiplier;
 exports.getDriftMetadata = getDriftMetadata;
 exports.getDriftStatesDto = getDriftStatesDto;
 exports.getEmodePairs = getEmodePairs;
+exports.getExactOutEstimate = getExactOutEstimate;
 exports.getHealthCacheStatusDescription = getHealthCacheStatusDescription;
 exports.getHealthSimulationTransactions = getHealthSimulationTransactions;
 exports.getJupLendFTokenMultiplier = getJupLendFTokenMultiplier;
@@ -54355,10 +55682,15 @@ exports.getOracleSourceNameFromKey = getOracleSourceNameFromKey;
 exports.getPrice = getPrice;
 exports.getPriceWithConfidence = getPriceWithConfidence;
 exports.getStakedBankMetadataMap = getStakedBankMetadataMap;
+exports.getSwapIxsForFlashloan = getSwapIxsForFlashloan;
+exports.getTitanExactOutEstimate = getTitanExactOutEstimate;
+exports.getTitanSwapIxsForFlashloan = getTitanSwapIxsForFlashloan;
+exports.getTotalAccountKeys = getTotalAccountKeys;
 exports.getTotalAssetQuantity = getTotalAssetQuantity;
 exports.getTotalLiabilityQuantity = getTotalLiabilityQuantity;
 exports.getTxSize = getTxSize;
 exports.getValidatorVoteAccountByBank = getValidatorVoteAccountByBank;
+exports.getWritableAccountKeys = getWritableAccountKeys;
 exports.groupToDto = groupToDto;
 exports.hasAccountFlag = hasAccountFlag;
 exports.hasEmodeEntryFlag = hasEmodeEntryFlag;
@@ -54427,6 +55759,7 @@ exports.makeWithdrawIx = makeWithdrawIx3;
 exports.makeWithdrawTx = makeWithdrawTx;
 exports.makeWrapSolIxs = makeWrapSolIxs;
 exports.mapBrokenFeedsToOraclePrices = mapBrokenFeedsToOraclePrices;
+exports.mapJupiterQuoteToSwapQuoteResult = mapJupiterQuoteToSwapQuoteResult;
 exports.mapPythBanksToOraclePrices = mapPythBanksToOraclePrices;
 exports.mapSwbBanksToOraclePrices = mapSwbBanksToOraclePrices;
 exports.marginfiAccountToDto = marginfiAccountToDto;
@@ -54463,6 +55796,7 @@ exports.toBankDto = toBankDto;
 exports.toBigNumber = toBigNumber;
 exports.toEmodeSettingsDto = toEmodeSettingsDto;
 exports.toInterestRateConfigDto = toInterestRateConfigDto;
+exports.toJupiterConfig = toJupiterConfig;
 exports.toNumber = toNumber;
 exports.uiToNative = uiToNative;
 exports.uiToNativeBigNumber = uiToNativeBigNumber;