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

package/dist/index.js

@@ -1,4 +1,4 @@
-import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, Transaction, StakeProgram, Keypair, StakeAuthorizationLayout, AddressLookupTableAccount, SYSVAR_RENT_PUBKEY, TransactionInstruction, LAMPORTS_PER_SOL, SYSVAR_INSTRUCTIONS_PUBKEY, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1 } from '@solana/web3.js';
+import { PublicKey, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram, TransactionMessage, VersionedTransaction, Transaction, AddressLookupTableAccount, SYSVAR_RENT_PUBKEY, StakeProgram, TransactionInstruction, LAMPORTS_PER_SOL, Keypair, StakeAuthorizationLayout, SYSVAR_INSTRUCTIONS_PUBKEY, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1 } from '@solana/web3.js';
 import { object, string, enums, array, assert } from 'superstruct';
 import BigNumber3, { BigNumber } from 'bignumber.js';
 import BN11, { BN } from 'bn.js';
@@ -10,6 +10,8 @@ import { Buffer as Buffer$1 } from 'buffer';
 import { deserialize } from 'borsh';
 import * as borsh from '@coral-xyz/borsh';
 import { struct as struct$1, bool as bool$1, publicKey as publicKey$1, array as array$1, u64 as u64$1, u8 as u8$1, u32 as u32$1, u128 } from '@coral-xyz/borsh';
+import WebSocket from 'ws';
+import { Encoder, Decoder } from '@msgpack/msgpack';
 import { SwapApi, Configuration, createJupiterApiClient } from '@jup-ag/api';
 import { AnchorUtils, PullFeed } from '@switchboard-xyz/on-demand';
 import { CrossbarClient } from '@switchboard-xyz/common';
@@ -89,12 +91,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 {
@@ -109,21 +114,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 }
     );
   }
   /**
@@ -167,6 +176,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
    */
@@ -319,6 +348,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 PublicKey("So11111111111111111111111111111111111111112");
@@ -14867,8 +14897,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;
   }
 }
@@ -14883,6 +14945,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;
   }
@@ -20120,6 +20223,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: {
@@ -44168,6 +44279,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 Encoder({ useBigInt64: true });
+var decoder = new 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(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 TransactionInstruction({
+    programId: new PublicKey(Buffer.from(ix.p, "base64")),
+    keys: ix.a.map((account) => ({
+      pubkey: new 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 AddressLookupTableAccount({
+      key: lutPubkeys[index],
+      state: AddressLookupTableAccount.deserialize(accountInfo.data)
+    });
+  }).filter((account) => account !== null);
+}
 
 // src/vendor/klend/utils/klend/interest-rate.utils.ts
 function getKaminoTotalSupply(reserve) {
@@ -46689,18 +47140,18 @@ async function buildLoopFlashloanTx({
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
   if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
-    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 PublicKey(depositOpts.depositBank.mint),
@@ -46708,36 +47159,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,
@@ -46754,140 +47215,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,
@@ -47077,18 +47534,18 @@ async function buildRepayWithCollatFlashloanTx({
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     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 PublicKey(repayOpts.repayBank.mint),
@@ -47096,41 +47553,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) {
@@ -47268,68 +47734,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
@@ -47483,11 +47951,16 @@ async function buildSwapCollateralFlashloanTx({
     actualWithdrawAmount,
     withdrawBank.mintDecimals
   );
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     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 */: {
@@ -47597,12 +48070,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,
@@ -47610,175 +48078,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 {
@@ -47916,7 +48377,6 @@ async function buildSwapDebtFlashloanTx({
     throw new Error("repayAmount must be greater than 0");
   }
   const actualRepayAmount = Math.min(repayAmount ?? totalPositionAmount, totalPositionAmount);
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
@@ -47927,313 +48387,120 @@ async function buildSwapDebtFlashloanTx({
     true,
     repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
   );
-  const jupiterApiClient = swapOpts.jupiterOptions?.configParams?.basePath ? new SwapApi(new Configuration(swapOpts.jupiterOptions.configParams)) : 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 PublicKey("SysvarC1ock11111111111111111111111111111111");
-async function makeMintStakedLstIx(params) {
-  const { amount, authority, stakeAccountPk, validator, connection } = params;
-  const pool = findPoolAddress(validator);
-  const lstMint = findPoolMintAddress(pool);
-  const poolStakeAuth = findPoolStakeAuthorityAddress(pool);
-  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
-  const [lstAccInfo, stakeAccInfoParsed, rentExemptReserve] = await Promise.all([
-    connection.getAccountInfo(lstAta),
-    connection.getParsedAccountInfo(stakeAccountPk),
-    connection.getMinimumBalanceForRentExemption(StakeProgram.space)
-  ]);
-  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
-  const amountLamports = Math.round(Number(amount) * LAMPORTS_PER_SOL);
-  const stakeAccLamports = Number(stakeAccParsed?.parsed?.info?.stake?.delegation?.stake ?? 0);
-  const isFullStake = amountLamports >= stakeAccLamports;
-  const instructions2 = [];
-  const signers = [];
-  if (!lstAccInfo) {
-    instructions2.push(
-      createAssociatedTokenAccountInstruction(authority, lstAta, authority, lstMint)
-    );
-  }
-  let targetStakePubkey;
-  if (!isFullStake) {
-    const splitStakeAccount = Keypair.generate();
-    signers.push(splitStakeAccount);
-    targetStakePubkey = splitStakeAccount.publicKey;
-    instructions2.push(
-      ...StakeProgram.split(
-        {
-          stakePubkey: stakeAccountPk,
-          authorizedPubkey: authority,
-          splitStakePubkey: splitStakeAccount.publicKey,
-          lamports: amountLamports
-        },
-        rentExemptReserve
-      ).instructions
-    );
-  } else {
-    targetStakePubkey = stakeAccountPk;
-  }
-  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
-    StakeProgram.authorize({
-      stakePubkey: targetStakePubkey,
-      authorizedPubkey: authority,
-      newAuthorizedPubkey: poolStakeAuth,
-      stakeAuthorizationType: StakeAuthorizationLayout.Staker
-    }).instructions,
-    StakeProgram.authorize({
-      stakePubkey: targetStakePubkey,
-      authorizedPubkey: authority,
-      newAuthorizedPubkey: poolStakeAuth,
-      stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer
-    }).instructions
-  ]);
-  [authorizeStakerIx[0], authorizeWithdrawIx[0]].forEach((ix) => {
-    if (ix) {
-      ix.keys = ix.keys.map((key) => ({
-        ...key,
-        isWritable: key.pubkey.equals(SYSVAR_CLOCK_ID2) ? false : key.isWritable
-      }));
+      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 TransactionMessage({
-    payerKey: params.authority,
-    recentBlockhash: blockhash,
-    instructions: instructions2
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    signers: keys,
-    addressLookupTables: luts,
-    type: "DEPOSIT_STAKE" /* DEPOSIT_STAKE */
-  });
-}
-async function makeRedeemStakedLstIx(params) {
-  const { amount, authority, validator, connection } = params;
-  const pool = findPoolAddress(validator);
-  const lstMint = findPoolMintAddress(pool);
-  const mintAuthority = findPoolMintAuthorityAddress(pool);
-  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
-  const rentExemption = await connection.getMinimumBalanceForRentExemption(
-    StakeProgram.space
-  );
-  const stakeAmount = new BigNumber3(new BigNumber3(amount).toString());
-  const instructions2 = [];
-  const signers = [];
-  const stakeAccount = Keypair.generate();
-  signers.push(stakeAccount);
-  instructions2.push(
-    SystemProgram.createAccount({
-      fromPubkey: authority,
-      newAccountPubkey: stakeAccount.publicKey,
-      lamports: rentExemption,
-      space: StakeProgram.space,
-      programId: StakeProgram.programId
-    })
-  );
-  instructions2.push(
-    createApproveInstruction(
-      lstAta,
-      mintAuthority,
-      authority,
-      BigInt(stakeAmount.multipliedBy(1e9).toFixed(0))
-    )
-  );
-  const withdrawStakeIx = await SinglePoolInstruction.withdrawStake(
-    pool,
-    stakeAccount.publicKey,
-    authority,
-    lstAta,
-    stakeAmount
-  );
-  instructions2.push(withdrawStakeIx);
-  return { instructions: instructions2, keys: signers };
-}
-async function makeRedeemStakedLstTx(params) {
-  const { connection, luts, blockhash: providedBlockhash } = params;
-  const { instructions: instructions2, keys } = await makeRedeemStakedLstIx(params);
-  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const message = new TransactionMessage({
-    payerKey: params.authority,
-    recentBlockhash: blockhash,
-    instructions: instructions2
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    signers: keys,
-    addressLookupTables: luts,
-    type: "WITHDRAW_STAKE" /* WITHDRAW_STAKE */
-  });
-}
-async function makeMergeStakeAccountsTx(params) {
-  const {
-    authority,
-    sourceStakeAccount,
-    destinationStakeAccount,
-    connection,
+  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 = StakeProgram.merge({
-    stakePubkey: destinationStakeAccount,
-    sourceStakePubKey: sourceStakeAccount,
-    authorizedPubkey: authority
-  }).instructions;
-  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const message = new TransactionMessage({
-    payerKey: authority,
-    recentBlockhash: blockhash,
-    instructions: mergeIx
-  }).compileToV0Message(luts);
-  const tx = new VersionedTransaction(message);
-  return addTransactionMetadata(tx, {
-    addressLookupTables: luts,
-    type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
+    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
@@ -48859,17 +49126,528 @@ function computeMaxWithdrawForBank(params) {
   const maxWithdraw = initUntiedCollateralForBank.div(initWeightedPrice);
   return maxWithdraw;
 }
+var TITAN_FEE_WALLET = new 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 TransactionInstruction({
+    programId: new PublicKey(ix.p),
+    keys: ix.a.map((account) => ({
+      pubkey: new 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 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 PublicKey(inputMint).toBytes(),
+        outputMint: new 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 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 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 PublicKey(inputMint).toBytes(),
+        outputMint: new 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 SwapApi(new Configuration(configParams)) : 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 PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
 var REFERRAL_ACCOUNT_PUBKEY = new PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
 var getFeeAccount = (mint) => {
-  const referralProgramPubkey = REFERRAL_PROGRAM_ID;
-  const referralAccountPubkey = REFERRAL_ACCOUNT_PUBKEY;
   const [feeAccount] = 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 PublicKey(feeAccount));
+  return { feeAccount, hasFeeAccount };
+};
 function deserializeJupiterInstruction(instruction) {
   return new TransactionInstruction({
     programId: new PublicKey(instruction.programId),
@@ -48881,17 +49659,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 SwapApi(new Configuration(configParams)) : createJupiterApiClient(configParams);
   const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
-  const feeAccount = getFeeAccount(new PublicKey(feeMint));
-  const hasFeeAccount = !!await connection.getAccountInfo(new PublicKey(feeAccount));
+  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new PublicKey(feeMint));
   const project0JupiterLut = (await connection.getAddressLookupTable(ADDRESS_LOOKUP_TABLE_FOR_SWAP))?.value;
   let finalQuoteParams = quoteParams;
   if (!hasFeeAccount) {
@@ -48901,67 +49688,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 PublicKey(address))
+    lutAddresses.map((address) => new 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 AddressLookupTableAccount({
-        key: new PublicKey(addressLookupTableAddress),
-        state: 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 AddressLookupTableAccount({
+      key: new PublicKey(addressLookupTableAddress),
+      state: 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
@@ -48979,6 +49744,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(endIndex) }
+  );
+  const endFlRemainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const endFlIx = sync_instructions_default.makeEndFlashLoanIx(
+    program.programId,
+    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
+    endFlRemainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false }))
+  );
+  const allNonSwapIxs = [beginFlIx, ...ixs, endFlIx];
+  const nonSwapMsg = new TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: PublicKey.default.toBase58(),
+    instructions: allNonSwapIxs
+  }).compileToV0Message(addressLookupTableAccounts);
+  const nonSwapSize = new VersionedTransaction(nonSwapMsg).serialize().length;
+  const { header, staticAccountKeys, addressTableLookups } = nonSwapMsg;
+  const nonSwapTotal = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  const sizeConstraint = MAX_TX_SIZE - nonSwapSize - SWAP_MERGE_OVERHEAD;
+  const maxSwapTotalAccounts = MAX_ACCOUNT_LOCKS - nonSwapTotal;
+  console.log("[flashloan-budget]", {
+    method: "compiled",
+    nonSwapSize,
+    nonSwapTotal,
+    sizeConstraint,
+    maxSwapTotalAccounts
+  });
+  return { sizeConstraint, maxSwapTotalAccounts };
+}
+function compileFlashloanPrecheck({
+  allIxs,
+  payer,
+  luts,
+  sizeConstraint,
+  swapIxCount,
+  swapLutCount
+}) {
+  const msg = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: PublicKey.default.toBase58(),
+    instructions: allIxs
+  }).compileToV0Message(luts);
+  const rawSize = new VersionedTransaction(msg).serialize().length;
+  const fullTxSize = rawSize + FL_IX_OVERHEAD;
+  const overshoot = fullTxSize - MAX_TX_SIZE;
+  const { header, staticAccountKeys, addressTableLookups } = msg;
+  const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
+  const writableLut = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+  const writableAccounts = writableStatic + writableLut;
+  const totalAccounts = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  console.log("[flashloan-precheck]", {
+    fullTxSize,
+    overshoot,
+    sizeConstraint,
+    writableAccounts,
+    totalAccounts,
+    staticKeys: staticAccountKeys.length,
+    numLuts: addressTableLookups.length,
+    swapIxCount,
+    swapLutCount
+  });
+  return { fullTxSize, overshoot, writableAccounts, totalAccounts };
+}
+async function buildBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  switch (config.type) {
+    case "borrow":
+      return makeBorrowIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        isSync: true,
+        opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "repay":
+      return makeRepayIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        repayAll: false,
+        isSync: true,
+        opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "deposit":
+      return buildDepositBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
+    case "withdraw":
+      return buildWithdrawBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMap,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
+  }
+}
+async function buildDepositBudgetIx(config, program, marginfiAccount, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  const opts = { wrapAndUnwrapSol: false, overrideInferAccounts };
+  switch (bank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeKaminoDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        isSync: true,
+        opts
+      });
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeDriftDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        driftMarketIndex: driftState.spotMarketState.marketIndex,
+        driftOracle: driftState.spotMarketState.oracle,
+        isSync: true,
+        opts
+      });
+    }
+    case 6 /* JUPLEND */: {
+      return makeJuplendDepositIx2({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        isSync: true,
+        opts
+      });
+    }
+    default: {
+      return makeDepositIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        isSync: true,
+        opts
+      });
+    }
+  }
+}
+async function buildWithdrawBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  const opts = { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts };
+  switch (bank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[bank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeKaminoWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        cTokenAmount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        reserve,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[bank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeDriftWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
+    }
+    case 6 /* JUPLEND */: {
+      const jupLendState = bankMetadataMap[bank.address.toBase58()]?.jupLendStates;
+      if (!jupLendState) {
+        throw TransactionBuildingError.jupLendStateNotFound(
+          bank.address.toBase58(),
+          bank.mint.toBase58(),
+          bank.tokenSymbol
+        );
+      }
+      return makeJuplendWithdrawIx2({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        jupLendingState: jupLendState.jupLendingState,
+        withdrawAll: false,
+        opts
+      });
+    }
+    default: {
+      return makeWithdrawIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        withdrawAll: false,
+        isSync: true,
+        opts
+      });
+    }
+  }
+}
+async function computeFlashloanSwapConstraints({
+  program,
+  marginfiAccount,
+  bankMap,
+  addressLookupTableAccounts,
+  bankMetadataMap,
+  primaryIx,
+  secondaryIx,
+  overrideInferAccounts
+}) {
+  const cuRequestIxs = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const [primaryResult, secondaryResult] = await Promise.all([
+    buildBudgetIx(
+      primaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    ),
+    buildBudgetIx(
+      secondaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    )
+  ]);
+  return computeFlashLoanNonSwapBudget({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts,
+    ixs: [...cuRequestIxs, ...primaryResult.instructions, ...secondaryResult.instructions]
+  });
+}
 
 // src/services/price/utils/smart-crank.utils.ts
 async function computeSmartCrank({
@@ -50182,7 +51381,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;
@@ -50197,7 +51396,7 @@ function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank
   }
   const totalDepositAmount = initialCollateral.times(new BigNumber3(clampedLeverage));
   const additionalDepositAmount = totalDepositAmount.minus(initialCollateral);
-  const totalBorrowAmount = additionalDepositAmount.times(depositOracleInfo.priceWeighted.lowestPrice).div(borrowOracleInfo.priceWeighted.highestPrice);
+  const totalBorrowAmount = additionalDepositAmount.times(new BigNumber3(depositPriceUsd)).div(new BigNumber3(borrowPriceUsd));
   return {
     totalBorrowAmount: totalBorrowAmount.decimalPlaces(
       borrowBank.mintDecimals,
@@ -51241,6 +52440,230 @@ function getValidatorVoteAccountByBank() {
   }
   return _voteAccountByBank;
 }
+async function computeStakedBankMultipliers(stakedBanks, connection) {
+  const multiplierByBank = /* @__PURE__ */ new Map();
+  if (stakedBanks.length === 0) {
+    return multiplierByBank;
+  }
+  const metadataMap = getStakedBankMetadataMap();
+  const stakedBankAddresses = [];
+  const poolStakeAddresses = [];
+  const lstMintAddresses = [];
+  for (const bank of stakedBanks) {
+    const metadata = metadataMap.get(bank.address.toBase58());
+    if (!metadata) {
+      multiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
+      continue;
+    }
+    const pool = findPoolAddress(new PublicKey(metadata.validatorVoteAccount));
+    stakedBankAddresses.push(bank.address.toBase58());
+    poolStakeAddresses.push(findPoolStakeAddress(pool));
+    lstMintAddresses.push(findPoolMintAddress(pool));
+  }
+  if (stakedBankAddresses.length === 0) {
+    return multiplierByBank;
+  }
+  const allAddresses = [
+    ...poolStakeAddresses.map((a) => a.toBase58()),
+    ...lstMintAddresses.map((a) => a.toBase58())
+  ];
+  const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(connection, allAddresses);
+  const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
+  const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
+  for (let i = 0; i < stakedBankAddresses.length; i++) {
+    const bankAddr = stakedBankAddresses[i];
+    const poolStakeInfo = poolStakeInfos[i];
+    const lstMintInfo = lstMintInfos[i];
+    if (!poolStakeInfo || !lstMintInfo) {
+      multiplierByBank.set(bankAddr, new BigNumber3(1));
+      continue;
+    }
+    const stakeLamports = poolStakeInfo.lamports;
+    const supplyBuffer = lstMintInfo.data.slice(36, 44);
+    const lstMintSupply = Number(Buffer.from(supplyBuffer).readBigUInt64LE(0));
+    if (lstMintSupply === 0) {
+      multiplierByBank.set(bankAddr, new BigNumber3(1));
+      continue;
+    }
+    const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL, 0);
+    const multiplier = new BigNumber3(adjustedStake).dividedBy(lstMintSupply);
+    multiplierByBank.set(bankAddr, multiplier);
+  }
+  return multiplierByBank;
+}
+var SYSVAR_CLOCK_ID2 = new PublicKey("SysvarC1ock11111111111111111111111111111111");
+async function makeMintStakedLstIx(params) {
+  const { amount, authority, stakeAccountPk, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const poolStakeAuth = findPoolStakeAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const [lstAccInfo, stakeAccInfoParsed, rentExemptReserve] = await Promise.all([
+    connection.getAccountInfo(lstAta),
+    connection.getParsedAccountInfo(stakeAccountPk),
+    connection.getMinimumBalanceForRentExemption(StakeProgram.space)
+  ]);
+  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
+  const amountLamports = Math.round(Number(amount) * LAMPORTS_PER_SOL);
+  const stakeAccLamports = Number(stakeAccParsed?.parsed?.info?.stake?.delegation?.stake ?? 0);
+  const isFullStake = amountLamports >= stakeAccLamports;
+  const instructions2 = [];
+  const signers = [];
+  if (!lstAccInfo) {
+    instructions2.push(
+      createAssociatedTokenAccountInstruction(authority, lstAta, authority, lstMint)
+    );
+  }
+  let targetStakePubkey;
+  if (!isFullStake) {
+    const splitStakeAccount = Keypair.generate();
+    signers.push(splitStakeAccount);
+    targetStakePubkey = splitStakeAccount.publicKey;
+    instructions2.push(
+      ...StakeProgram.split(
+        {
+          stakePubkey: stakeAccountPk,
+          authorizedPubkey: authority,
+          splitStakePubkey: splitStakeAccount.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      ).instructions
+    );
+  } else {
+    targetStakePubkey = stakeAccountPk;
+  }
+  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
+    StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: StakeAuthorizationLayout.Staker
+    }).instructions,
+    StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer
+    }).instructions
+  ]);
+  [authorizeStakerIx[0], authorizeWithdrawIx[0]].forEach((ix) => {
+    if (ix) {
+      ix.keys = ix.keys.map((key) => ({
+        ...key,
+        isWritable: key.pubkey.equals(SYSVAR_CLOCK_ID2) ? false : key.isWritable
+      }));
+    }
+  });
+  instructions2.push(...authorizeStakerIx, ...authorizeWithdrawIx);
+  const depositStakeIx = await SinglePoolInstruction.depositStake(
+    pool,
+    targetStakePubkey,
+    lstAta,
+    authority
+  );
+  instructions2.push(depositStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeMintStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeMintStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "DEPOSIT_STAKE" /* DEPOSIT_STAKE */
+  });
+}
+async function makeRedeemStakedLstIx(params) {
+  const { amount, authority, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const mintAuthority = findPoolMintAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const rentExemption = await connection.getMinimumBalanceForRentExemption(
+    StakeProgram.space
+  );
+  const stakeAmount = new BigNumber3(new BigNumber3(amount).toString());
+  const instructions2 = [];
+  const signers = [];
+  const stakeAccount = Keypair.generate();
+  signers.push(stakeAccount);
+  instructions2.push(
+    SystemProgram.createAccount({
+      fromPubkey: authority,
+      newAccountPubkey: stakeAccount.publicKey,
+      lamports: rentExemption,
+      space: StakeProgram.space,
+      programId: StakeProgram.programId
+    })
+  );
+  instructions2.push(
+    createApproveInstruction(
+      lstAta,
+      mintAuthority,
+      authority,
+      BigInt(stakeAmount.multipliedBy(1e9).toFixed(0))
+    )
+  );
+  const withdrawStakeIx = await SinglePoolInstruction.withdrawStake(
+    pool,
+    stakeAccount.publicKey,
+    authority,
+    lstAta,
+    stakeAmount
+  );
+  instructions2.push(withdrawStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeRedeemStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeRedeemStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "WITHDRAW_STAKE" /* WITHDRAW_STAKE */
+  });
+}
+async function makeMergeStakeAccountsTx(params) {
+  const {
+    authority,
+    sourceStakeAccount,
+    destinationStakeAccount,
+    connection,
+    luts,
+    blockhash: providedBlockhash
+  } = params;
+  const mergeIx = StakeProgram.merge({
+    stakePubkey: destinationStakeAccount,
+    sourceStakePubKey: sourceStakeAccount,
+    authorizedPubkey: authority
+  }).instructions;
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new TransactionMessage({
+    payerKey: authority,
+    recentBlockhash: blockhash,
+    instructions: mergeIx
+  }).compileToV0Message(luts);
+  const tx = new VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    addressLookupTables: luts,
+    type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
+  });
+}
 async function getKaminoMetadata(options) {
   const kaminoBanks = options.banks.filter((b) => b.config.assetTag === 3 /* KAMINO */);
   const DEFAULT_PUBKEY = PublicKey.default;
@@ -52664,7 +54087,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
@@ -52702,7 +54125,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
@@ -52742,7 +54165,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
@@ -52782,7 +54205,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
@@ -53677,66 +55100,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
   // ----------------------------------------------------------------------------
   /**
@@ -54006,56 +55369,11 @@ var Project0Client = class _Project0Client {
           break;
       }
     });
-    const stakedBanks = banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */);
-    if (stakedBanks.length > 0) {
-      const metadataMap = getStakedBankMetadataMap();
-      const stakedBankAddresses = [];
-      const poolStakeAddresses = [];
-      const lstMintAddresses = [];
-      for (const bank of stakedBanks) {
-        const metadata = metadataMap.get(bank.address.toBase58());
-        if (!metadata) {
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3(1));
-          continue;
-        }
-        const pool = findPoolAddress(new PublicKey(metadata.validatorVoteAccount));
-        stakedBankAddresses.push(bank.address.toBase58());
-        poolStakeAddresses.push(findPoolStakeAddress(pool));
-        lstMintAddresses.push(findPoolMintAddress(pool));
-      }
-      if (stakedBankAddresses.length > 0) {
-        const allAddresses = [
-          ...poolStakeAddresses.map((a) => a.toBase58()),
-          ...lstMintAddresses.map((a) => a.toBase58())
-        ];
-        const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(
-          connection,
-          allAddresses
-        );
-        const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
-        const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
-        for (let i = 0; i < stakedBankAddresses.length; i++) {
-          const bankAddr = stakedBankAddresses[i];
-          const poolStakeInfo = poolStakeInfos[i];
-          const lstMintInfo = lstMintInfos[i];
-          if (!poolStakeInfo || !lstMintInfo) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3(1));
-            continue;
-          }
-          const stakeLamports = poolStakeInfo.lamports;
-          const supplyBuffer = lstMintInfo.data.slice(36, 44);
-          const lstMintSupply = Number(Buffer.from(supplyBuffer).readBigUInt64LE(0));
-          if (lstMintSupply === 0) {
-            assetShareMultiplierByBank.set(bankAddr, new BigNumber3(1));
-            continue;
-          }
-          const LAMPORTS_PER_SOL5 = 1e9;
-          const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL5, 0);
-          const multiplier = new BigNumber3(adjustedStake).dividedBy(lstMintSupply);
-          assetShareMultiplierByBank.set(bankAddr, multiplier);
-        }
-      }
-    }
+    const stakedMultipliers = await computeStakedBankMultipliers(
+      banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */),
+      connection
+    );
+    stakedMultipliers.forEach((v, k) => assetShareMultiplierByBank.set(k, v));
     const emodePairs = getEmodePairs(banksArray);
     return new _Project0Client(
       program,
@@ -54097,6 +55415,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_ORACLE_MAX_AGE, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkMultipleOraclesCrankability, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeHealthComponentsWithoutBiasFromBalances, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountAddresses, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isFlashloan, isV0Tx, isWeightedPrice, isWholePosition, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeClearEmissionsIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, resolveAmount, serializeBankConfigOpt, serializeInterestRateConfig, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, toBankConfigDto, toBankDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toNumber, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
+export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_ORACLE_MAX_AGE, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkMultipleOraclesCrankability, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, compileFlashloanPrecheck, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeHealthComponentsWithoutBiasFromBalances, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountAddresses, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isFlashloan, isV0Tx, isWeightedPrice, isWholePosition, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBundleTipIx, makeClearEmissionsIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSwapCollateralTx, makeSwapDebtTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, resolveAmount, serializeBankConfigOpt, serializeInterestRateConfig, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, toBankConfigDto, toBankDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map