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

package/dist/index.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';
@@ -91,10 +93,14 @@ function getConfig(environment = "production", overrides) {
 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["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 {
@@ -126,6 +132,20 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { 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(
+      "SWAP_SIZE_EXCEEDED_REPAY" /* SWAP_SIZE_EXCEEDED_REPAY */,
+      `${provider ?? "Swap"} instruction size exceeds available transaction size`,
+      { bytes, accountKeys, provider }
+    );
+  }
   /**
    * Failed to crank oracles for one or more banks
    */
@@ -167,6 +187,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 +359,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 +14908,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 +14956,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 +20234,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 +44290,330 @@ 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";
+      ws.on("open", () => {
+        resolve(new _V1Client(ws));
+      });
+      ws.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  // --- 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) {
@@ -46457,116 +46903,81 @@ async function makeJuplendDepositTx(params) {
   });
   return solanaTx;
 }
-async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
-  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
-    program.programId,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    { endIndex: new BN11(endIndex) }
-  ) : await instructions_default.makeBeginFlashLoanIx(
+async function makeRepayIx3({
+  program,
+  bank,
+  tokenProgram,
+  amount,
+  authority,
+  accountAddress,
+  repayAll = false,
+  isSync = false,
+  opts = {}
+}) {
+  const wrapAndUnwrapSol = opts.wrapAndUnwrapSol ?? true;
+  const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
+  const repayIxs = [];
+  const userAta = getAssociatedTokenAddressSync(bank.mint, authority, true, tokenProgram);
+  const remainingAccounts = tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? [{ pubkey: bank.mint, isSigner: false, isWritable: false }] : [];
+  if (bank.mint.equals(NATIVE_MINT) && wrapAndUnwrapSol) {
+    repayIxs.push(...makeWrapSolIxs(authority, new BigNumber(amount).minus(wSolBalanceUi)));
+  }
+  const repayIx = !isSync || !opts.overrideInferAccounts?.group ? await instructions_default.makeRepayIx(
     program,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group,
+      liquidityVault: opts.overrideInferAccounts?.liquidityVault
     },
-    { endIndex: new BN11(endIndex) }
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
-  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
-  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
+  ) : sync_instructions_default.makeRepayIx(
     program.programId,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  ) : await instructions_default.makeEndFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group
     },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
   );
-  return { instructions: [ix], keys: [] };
+  repayIxs.push(repayIx);
+  return {
+    instructions: repayIxs,
+    keys: []
+  };
 }
-async function makeFlashLoanTx({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  blockhash,
-  addressLookupTableAccounts,
-  signers,
-  isSync
-}) {
-  const endIndex = ixs.length + 1;
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
-    const b = bankMap.get(account.toBase58());
-    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
-    return b;
-  });
-  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    endIndex,
-    marginfiAccount.authority,
-    isSync
-  );
-  const endFlashLoanIx = await makeEndFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    projectedActiveBanks,
-    marginfiAccount.authority,
-    isSync
-  );
-  const message = new TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: blockhash,
-    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
-  }).compileToV0Message(addressLookupTableAccounts);
-  const tx = addTransactionMetadata(new VersionedTransaction(message), {
-    addressLookupTables: addressLookupTableAccounts,
-    type: "FLASHLOAN" /* FLASHLOAN */,
-    signers
+async function makeRepayTx(params) {
+  const { luts, ...depositIxParams } = params;
+  const ixs = await makeRepayIx3(depositIxParams);
+  const tx = new Transaction().add(...ixs.instructions);
+  tx.feePayer = params.authority;
+  const solanaTx = addTransactionMetadata(tx, {
+    type: "REPAY" /* REPAY */,
+    signers: ixs.keys,
+    addressLookupTables: luts
   });
-  if (signers) {
-    tx.sign(signers);
-  }
-  return tx;
+  return solanaTx;
 }
-
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
+async function makeRepayWithCollatTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    depositOpts,
-    borrowOpts,
+    withdrawOpts,
+    repayOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
+    crossbarUrl
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -46574,34 +46985,34 @@ async function makeLoopTx(params) {
     authority: marginfiAccount.authority,
     tokens: [
       {
-        mint: borrowOpts.borrowBank.mint,
-        tokenProgram: borrowOpts.tokenProgram
+        mint: repayOpts.repayBank.mint,
+        tokenProgram: repayOpts.tokenProgram
       },
       {
-        mint: depositOpts.depositBank.mint,
-        tokenProgram: depositOpts.tokenProgram
+        mint: withdrawOpts.withdrawBank.mint,
+        tokenProgram: withdrawOpts.tokenProgram
       }
     ]
   });
-  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
+  const updateJuplendMarketIxs = makeUpdateJupLendRateIxs(
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address],
+    bankMetadataMap
   );
   const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address],
+    bankMetadataMap
   );
   const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
     marginfiAccount,
     bankMap,
-    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
+    [withdrawOpts.withdrawBank.address, repayOpts.repayBank.address],
     bankMetadataMap
   );
-  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
+  const { flashloanTx, setupInstructions, swapQuote, amountToRepay, withdrawIxs, repayIxs } = await buildRepayWithCollatFlashloanTx({
     ...params,
     blockhash
   });
@@ -46611,7 +47022,7 @@ async function makeLoopTx(params) {
     }
     if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
       const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(repayOpts.repayBank.mint)) {
         return false;
       }
     }
@@ -46623,24 +47034,18 @@ async function makeLoopTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    instructions: [...withdrawIxs.instructions, ...repayIxs.instructions],
     program,
     connection,
     crossbarUrl
   });
   let additionalTxs = [];
-  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
-    setupIxs.push(
-      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber(depositOpts.inputDepositAmount))
-    );
-  }
-  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
+  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
     const ixs = [
-      ...additionalIxs,
       ...setupIxs,
       ...kaminoRefreshIxs.instructions,
       ...updateDriftMarketIxs.instructions,
-      ...updateJupLendRateIxs.instructions
+      ...updateJuplendMarketIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -46670,300 +47075,835 @@ async function makeLoopTx(params) {
     );
   }
   const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
+  return { transactions, swapQuote, amountToRepay };
 }
-async function buildLoopFlashloanTx({
+async function buildRepayWithCollatFlashloanTx({
   program,
   marginfiAccount,
   bankMap,
-  borrowOpts,
-  depositOpts,
+  withdrawOpts,
+  repayOpts,
   bankMetadataMap,
+  assetShareValueMultiplierByBank,
   addressLookupTableAccounts,
   connection,
   swapOpts,
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
-  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
-    swapResult.push({
-      amountToDeposit: borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0),
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+  let amountToRepay;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
+  if (repayOpts.repayBank.mint.equals(withdrawOpts.withdrawBank.mint)) {
+    amountToRepay = withdrawOpts.withdrawAmount;
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new PublicKey(depositOpts.depositBank.mint),
+      new PublicKey(repayOpts.repayBank.mint),
       marginfiAccount.authority,
       true,
-      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const 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: "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
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
-    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
+    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) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
+        );
+      }
+      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
+      const adjustedAmount = new BigNumber(withdrawOpts.withdrawAmount).div(multiplier).times(1.0001).toNumber();
+      withdrawIxs = await makeKaminoWithdrawIx3({
+        program,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        cTokenAmount: adjustedAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        reserve,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
       });
-    });
+      break;
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
+        );
+      }
+      withdrawIxs = await makeDriftWithdrawIx3({
+        program,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    case 6 /* JUPLEND */: {
+      const jupLendState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.jupLendStates;
+      if (!jupLendState) {
+        throw TransactionBuildingError.jupLendStateNotFound(
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
+        );
+      }
+      withdrawIxs = await makeJuplendWithdrawIx2({
+        program,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        jupLendingState: jupLendState.jupLendingState,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    default: {
+      withdrawIxs = await makeWithdrawIx3({
+        program,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: withdrawOpts.withdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        withdrawAll: isWholePosition(
+          {
+            amount: withdrawOpts.totalPositionAmount,
+            isLending: true
+          },
+          withdrawOpts.withdrawAmount,
+          withdrawOpts.withdrawBank.mintDecimals
+        ),
+        isSync: false,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
   }
-  const borrowIxs = await makeBorrowIx3({
+  const repayIxs = await makeRepayIx3({
     program,
-    bank: borrowOpts.borrowBank,
-    bankMap,
-    tokenProgram: borrowOpts.tokenProgram,
-    amount: borrowOpts.borrowAmount,
-    marginfiAccount,
+    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: {
-      createAtas: false,
       wrapAndUnwrapSol: false,
       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;
-      }
-      case 4 /* DRIFT */: {
-        const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
-        if (!driftState) {
-          throw TransactionBuildingError.driftStateNotFound(
-            depositOpts.depositBank.address.toBase58(),
-            depositOpts.depositBank.mint.toBase58(),
-            depositOpts.depositBank.tokenSymbol
-          );
-        }
-        const driftMarketIndex = driftState.spotMarketState.marketIndex;
-        const driftOracle = driftState.spotMarketState.oracle;
-        depositIxs = await makeDriftDepositIx3({
-          program,
-          bank: depositOpts.depositBank,
-          tokenProgram: depositOpts.tokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          driftMarketIndex,
-          driftOracle,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
-      }
-      case 6 /* JUPLEND */: {
-        depositIxs = await makeJuplendDepositIx2({
-          program,
-          bank: depositOpts.depositBank,
-          tokenProgram: depositOpts.tokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
+  const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    ...swapInstructions,
+    ...repayIxs.instructions
+  ];
+  if (swapInstructions.length > 0) {
+    compileFlashloanPrecheck({
+      allIxs: allNonFlIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint: sizeConstraintUsed,
+      swapIxCount: swapInstructions.length,
+      swapLutCount: swapLookupTables.length
+    });
+  }
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: true
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededRepay(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    repayIxs,
+    amountToRepay
+  };
+}
+
+// src/services/account/utils/flashloan-size.utils.ts
+var SWAP_MERGE_OVERHEAD = 150;
+var FL_IX_OVERHEAD = 52;
+function compactU16Size(n) {
+  return n < 128 ? 1 : n < 16384 ? 2 : 3;
+}
+function computeV0TxSize(ixs, payerKey, luts) {
+  const keyMap = /* @__PURE__ */ new Map();
+  const payerStr = payerKey.toBase58();
+  keyMap.set(payerStr, { isSigner: true, isWritable: true });
+  const programIds = /* @__PURE__ */ new Set();
+  for (const ix of ixs) {
+    const progStr = ix.programId.toBase58();
+    programIds.add(progStr);
+    if (!keyMap.has(progStr)) {
+      keyMap.set(progStr, { isSigner: false, isWritable: false });
+    }
+    for (const meta of ix.keys) {
+      const keyStr = meta.pubkey.toBase58();
+      const existing = keyMap.get(keyStr);
+      if (existing) {
+        existing.isSigner = existing.isSigner || meta.isSigner;
+        existing.isWritable = existing.isWritable || meta.isWritable;
+      } else {
+        keyMap.set(keyStr, { isSigner: meta.isSigner, isWritable: meta.isWritable });
       }
-      default: {
-        depositIxs = await makeDepositIx3({
-          program,
-          bank: depositOpts.depositBank,
-          tokenProgram: depositOpts.tokenProgram,
-          amount: amountToDeposit,
-          accountAddress: marginfiAccount.address,
-          authority: marginfiAccount.authority,
-          group: marginfiAccount.group,
-          opts: {
-            wrapAndUnwrapSol: false,
-            overrideInferAccounts
-          }
-        });
-        break;
+    }
+  }
+  const 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 });
       }
     }
-    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);
+  }
+  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 {
-        continue;
+        lutReadonlyIdxs[lutEntry.lutIdx].add(lutEntry.addrIdx);
       }
     } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        borrowIxs,
-        depositIxs,
-        amountToDeposit
-      };
+      numStaticKeys++;
+      if (props.isWritable) numWritableStaticKeys++;
     }
   }
-  throw new Error("Failed to build repay with collateral flashloan tx");
-}
-async function makeRepayIx3({
+  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,
-  bank,
-  tokenProgram,
-  amount,
-  authority,
-  accountAddress,
-  repayAll = false,
-  isSync = false,
-  opts = {}
+  marginfiAccount,
+  ixs,
+  bankMap,
+  addressLookupTableAccounts
 }) {
-  const wrapAndUnwrapSol = opts.wrapAndUnwrapSol ?? true;
-  const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
-  const repayIxs = [];
-  const userAta = getAssociatedTokenAddressSync(bank.mint, authority, true, tokenProgram);
-  const remainingAccounts = tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? [{ pubkey: bank.mint, isSigner: false, isWritable: false }] : [];
-  if (bank.mint.equals(NATIVE_MINT) && wrapAndUnwrapSol) {
-    repayIxs.push(...makeWrapSolIxs(authority, new BigNumber(amount).minus(wSolBalanceUi)));
+  const 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
+      );
   }
-  const repayIx = !isSync || !opts.overrideInferAccounts?.group ? await instructions_default.makeRepayIx(
+}
+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/account/actions/flash-loan.ts
+async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
+  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
+    program.programId,
     {
-      marginfiAccount: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group,
-      liquidityVault: opts.overrideInferAccounts?.liquidityVault
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
-  ) : sync_instructions_default.makeRepayIx(
+    { endIndex: new BN11(endIndex) }
+  ) : await instructions_default.makeBeginFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { endIndex: new BN11(endIndex) }
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
+  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
     program.programId,
     {
-      marginfiAccount: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  ) : await instructions_default.makeEndFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
   );
-  repayIxs.push(repayIx);
-  return {
-    instructions: repayIxs,
-    keys: []
-  };
+  return { instructions: [ix], keys: [] };
 }
-async function makeRepayTx(params) {
-  const { luts, ...depositIxParams } = params;
-  const ixs = await makeRepayIx3(depositIxParams);
-  const tx = new Transaction().add(...ixs.instructions);
-  tx.feePayer = params.authority;
-  const solanaTx = addTransactionMetadata(tx, {
-    type: "REPAY" /* REPAY */,
-    signers: ixs.keys,
-    addressLookupTables: luts
+async function makeFlashLoanTx({
+  program,
+  marginfiAccount,
+  ixs,
+  bankMap,
+  blockhash,
+  addressLookupTableAccounts,
+  signers,
+  isSync
+}) {
+  const endIndex = ixs.length + 1;
+  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
+    marginfiAccount.balances,
+    ixs,
+    program
+  );
+  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
+    const b = bankMap.get(account.toBase58());
+    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
+    return b;
   });
-  return solanaTx;
+  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    endIndex,
+    marginfiAccount.authority,
+    isSync
+  );
+  const endFlashLoanIx = await makeEndFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    projectedActiveBanks,
+    marginfiAccount.authority,
+    isSync
+  );
+  const message = new TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: blockhash,
+    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
+  }).compileToV0Message(addressLookupTableAccounts);
+  const tx = addTransactionMetadata(new VersionedTransaction(message), {
+    addressLookupTables: addressLookupTableAccounts,
+    type: "FLASHLOAN" /* FLASHLOAN */,
+    signers
+  });
+  if (signers) {
+    tx.sign(signers);
+  }
+  return tx;
 }
-async function makeRepayWithCollatTx(params) {
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    withdrawOpts,
-    repayOpts,
+    depositOpts,
+    borrowOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl
+    crossbarUrl,
+    additionalIxs = []
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -46971,34 +47911,34 @@ async function makeRepayWithCollatTx(params) {
     authority: marginfiAccount.authority,
     tokens: [
       {
-        mint: repayOpts.repayBank.mint,
-        tokenProgram: repayOpts.tokenProgram
+        mint: borrowOpts.borrowBank.mint,
+        tokenProgram: borrowOpts.tokenProgram
       },
       {
-        mint: withdrawOpts.withdrawBank.mint,
-        tokenProgram: withdrawOpts.tokenProgram
+        mint: depositOpts.depositBank.mint,
+        tokenProgram: depositOpts.tokenProgram
       }
     ]
   });
-  const updateJuplendMarketIxs = makeUpdateJupLendRateIxs(
-    marginfiAccount,
-    bankMap,
-    [withdrawOpts.withdrawBank.address],
-    bankMetadataMap
+  const updateJupLendRateIxs = makeUpdateJupLendRateIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
   );
   const updateDriftMarketIxs = makeUpdateDriftMarketIxs(
-    marginfiAccount,
-    bankMap,
-    [withdrawOpts.withdrawBank.address],
-    bankMetadataMap
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap
   );
   const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
     marginfiAccount,
     bankMap,
-    [withdrawOpts.withdrawBank.address, repayOpts.repayBank.address],
+    [borrowOpts.borrowBank.address, depositOpts.depositBank.address],
     bankMetadataMap
   );
-  const { flashloanTx, setupInstructions, swapQuote, amountToRepay, withdrawIxs, repayIxs } = await buildRepayWithCollatFlashloanTx({
+  const { flashloanTx, setupInstructions, swapQuote, amountToDeposit, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
     ...params,
     blockhash
   });
@@ -47008,7 +47948,7 @@ async function makeRepayWithCollatTx(params) {
     }
     if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
       const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(repayOpts.repayBank.mint)) {
+      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
         return false;
       }
     }
@@ -47020,18 +47960,24 @@ async function makeRepayWithCollatTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...withdrawIxs.instructions, ...repayIxs.instructions],
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
     program,
     connection,
     crossbarUrl
   });
   let additionalTxs = [];
-  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
+  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
+    setupIxs.push(
+      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber(depositOpts.inputDepositAmount))
+    );
+  }
+  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
     const ixs = [
+      ...additionalIxs,
       ...setupIxs,
       ...kaminoRefreshIxs.instructions,
       ...updateDriftMarketIxs.instructions,
-      ...updateJuplendMarketIxs.instructions
+      ...updateJupLendRateIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -47061,110 +48007,121 @@ async function makeRepayWithCollatTx(params) {
     );
   }
   const transactions = [...additionalTxs, flashloanTx];
-  return { transactions, swapQuote, amountToRepay };
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
 }
-async function buildRepayWithCollatFlashloanTx({
+async function buildLoopFlashloanTx({
   program,
   marginfiAccount,
   bankMap,
-  withdrawOpts,
-  repayOpts,
+  borrowOpts,
+  depositOpts,
   bankMetadataMap,
-  assetShareValueMultiplierByBank,
   addressLookupTableAccounts,
   connection,
   swapOpts,
   overrideInferAccounts,
   blockhash
 }) {
-  const swapResult = [];
   const cuRequestIxs = [
     ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
-  if (repayOpts.repayBank.mint.equals(withdrawOpts.withdrawBank.mint)) {
-    swapResult.push({
-      amountToRepay: withdrawOpts.withdrawAmount,
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
+  if (depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint)) {
+    amountToDeposit = borrowOpts.borrowAmount + (depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0);
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
-      new PublicKey(repayOpts.repayBank.mint),
+      new PublicKey(depositOpts.depositBank.mint),
       marginfiAccount.authority,
       true,
-      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const 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: "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 { 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 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;
   }
-  let withdrawIxs;
-  switch (withdrawOpts.withdrawBank.config.assetTag) {
+  const borrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowOpts.borrowBank,
+    bankMap,
+    tokenProgram: borrowOpts.tokenProgram,
+    amount: borrowOpts.borrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: false,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
+  });
+  let depositIxs;
+  switch (depositOpts.depositBank.config.assetTag) {
     case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
+      const reserve = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.kaminoStates?.reserveState;
       if (!reserve) {
         throw TransactionBuildingError.kaminoReserveNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
         );
       }
-      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
-      const adjustedAmount = new BigNumber(withdrawOpts.withdrawAmount).div(multiplier).times(1.0001).toNumber();
-      withdrawIxs = await makeKaminoWithdrawIx3({
+      depositIxs = await makeKaminoDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        cTokenAmount: adjustedAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
         reserve,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47172,35 +48129,27 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.driftStates;
+      const driftState = bankMetadataMap[depositOpts.depositBank.address.toBase58()]?.driftStates;
       if (!driftState) {
         throw TransactionBuildingError.driftStateNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
+          depositOpts.depositBank.address.toBase58(),
+          depositOpts.depositBank.mint.toBase58(),
+          depositOpts.depositBank.tokenSymbol
         );
       }
-      withdrawIxs = await makeDriftWithdrawIx3({
+      const driftMarketIndex = driftState.spotMarketState.marketIndex;
+      const driftOracle = driftState.spotMarketState.oracle;
+      depositIxs = await makeDriftDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
-        driftSpotMarket: driftState.spotMarketState,
-        userRewards: driftState.userRewards,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
+        group: marginfiAccount.group,
+        driftMarketIndex,
+        driftOracle,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47208,33 +48157,15 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     case 6 /* JUPLEND */: {
-      const jupLendState = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.jupLendStates;
-      if (!jupLendState) {
-        throw TransactionBuildingError.jupLendStateNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
-        );
-      }
-      withdrawIxs = await makeJuplendWithdrawIx2({
+      depositIxs = await makeJuplendDepositIx2({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
+        group: marginfiAccount.group,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47242,25 +48173,15 @@ async function buildRepayWithCollatFlashloanTx({
       break;
     }
     default: {
-      withdrawIxs = await makeWithdrawIx3({
+      depositIxs = await makeDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        amount: withdrawOpts.withdrawAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
+        group: marginfiAccount.group,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47268,68 +48189,48 @@ 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 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 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
-      };
-    }
   }
-  throw new Error("Failed to build repay with collateral flashloan tx");
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededLoop(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    borrowIxs,
+    depositIxs,
+    amountToDeposit
+  };
 }
 
 // src/services/account/actions/emissions.ts
@@ -47483,11 +48384,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 +48503,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 +48511,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
+      swapOpts,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
     });
-    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
-      });
-    });
-  }
-  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;
     }
   }
-  throw new Error("Failed to build swap collateral flashloan tx");
+  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
+    });
+  }
+  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.swapSizeExceededLoop(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    depositIxs
+  };
 }
 async function makeSwapDebtTx(params) {
   const {
@@ -47916,7 +48810,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,140 +48820,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
-      };
+      repayBank.mintDecimals
+    ),
+    isSync: true,
+    opts: {
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
     }
+  });
+  const luts = [
+    ...addressLookupTableAccounts ?? [],
+    ...swapResponses.addressLookupTableAddresses
+  ];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...swapResponses.swapInstructions,
+    ...repayIxs.instructions
+  ];
+  compileFlashloanPrecheck({
+    allIxs: allNonFlIxs,
+    payer: marginfiAccount.authority,
+    luts,
+    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.swapSizeExceededLoop(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
   }
-  throw new Error("Failed to build swap debt flashloan tx");
+  return {
+    flashloanTx,
+    setupInstructions: swapResponses.setupInstructions,
+    swapQuote: quoteResponse,
+    borrowIxs,
+    repayIxs
+  };
 }
 var SYSVAR_CLOCK_ID2 = new PublicKey("SysvarC1ock11111111111111111111111111111111");
 async function makeMintStakedLstIx(params) {
@@ -48859,17 +49732,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",
+        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 +50265,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 +50294,44 @@ 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 maxAccounts = maxSwapAccounts ?? 40;
+  const swapQuote = await jupiterApiClient.quoteGet({
+    ...finalQuoteParams,
+    maxAccounts
+  });
+  const swapInstructionResponse = await jupiterApiClient.swapInstructionsPost({
+    swapRequest: {
+      quoteResponse: swapQuote,
+      userPublicKey: authority.toBase58(),
+      feeAccount: hasFeeAccount ? feeAccount : void 0,
+      wrapAndUnwrapSol: false,
+      destinationTokenAccount: destinationTokenAccount.toBase58()
+    }
+  });
+  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
@@ -50182,7 +51552,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 +51567,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,
@@ -52664,7 +54034,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 +54072,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 +54112,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 +54152,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
@@ -54097,6 +55467,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, 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