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

package/dist/index.cjs

@@ -11,6 +11,8 @@ var bufferLayoutUtils = require('@solana/buffer-layout-utils');
 var buffer = require('buffer');
 var borsh$1 = require('borsh');
 var borsh = require('@coral-xyz/borsh');
+var WebSocket = require('ws');
+var msgpack = require('@msgpack/msgpack');
 var api = require('@jup-ag/api');
 var onDemand = require('@switchboard-xyz/on-demand');
 var common = require('@switchboard-xyz/common');
@@ -39,6 +41,7 @@ var BigNumber3__default = /*#__PURE__*/_interopDefault(BigNumber3);
 var BN11__default = /*#__PURE__*/_interopDefault(BN11);
 var Decimal3__default = /*#__PURE__*/_interopDefault(Decimal3);
 var borsh__namespace = /*#__PURE__*/_interopNamespace(borsh);
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
 
 // src/config.ts
 
@@ -117,10 +120,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 {
@@ -152,6 +159,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
    */
@@ -193,6 +214,26 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { bankAddress, bankMint, bankSymbol }
     );
   }
+  /**
+   * Failed to update Switchboard price feeds
+   */
+  static switchboardFeedUpdateFailed(oracleKeys, reason) {
+    return new _TransactionBuildingError(
+      "SWITCHBOARD_FEED_UPDATE_FAILED" /* SWITCHBOARD_FEED_UPDATE_FAILED */,
+      `Switchboard feed update failed: ${reason}`,
+      { oracleKeys, reason }
+    );
+  }
+  /**
+   * Failed to get a swap quote from any provider
+   */
+  static swapQuoteFailed(provider, inputMint, outputMint, reason) {
+    return new _TransactionBuildingError(
+      "SWAP_QUOTE_FAILED" /* SWAP_QUOTE_FAILED */,
+      `${provider} swap quote failed for ${inputMint} \u2192 ${outputMint}: ${reason}`,
+      { provider, inputMint, outputMint, reason }
+    );
+  }
   /**
    * Generic escape hatch for custom errors
    */
@@ -345,6 +386,7 @@ var MAX_U64 = BigInt("18446744073709551615").toString();
 
 // src/constants/transaction.consts.ts
 var MAX_TX_SIZE = 1232;
+var MAX_ACCOUNT_LOCKS = 64;
 var BUNDLE_TX_SIZE = 81;
 var PRIORITY_TX_SIZE = 44;
 var WSOL_MINT = new web3_js.PublicKey("So11111111111111111111111111111111111111112");
@@ -14893,8 +14935,40 @@ function getTxSize(tx) {
   const signaturesSize = (numRequiredSignatures - numSigners) * 64 + 1;
   try {
     const baseTxSize = isVersioned ? tx.serialize().length : tx.serialize({ requireAllSignatures: false, verifySignatures: false }).length;
-    return baseTxSize + feePayerSize + signaturesSize;
-  } catch {
+    const totalSize = baseTxSize + feePayerSize + signaturesSize;
+    if (isVersioned && totalSize > 1232) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const lutWritable = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+      const lutReadonly = addressTableLookups.reduce((s, l) => s + l.readonlyIndexes.length, 0);
+      console.warn("[getTxSize] oversized TX", {
+        totalSize,
+        overshoot: totalSize - 1232,
+        staticKeys: staticAccountKeys.length,
+        numSignatures: header.numRequiredSignatures,
+        numLuts: addressTableLookups.length,
+        lutWritable,
+        lutReadonly,
+        totalAccounts: staticAccountKeys.length + lutWritable + lutReadonly
+      });
+    }
+    return totalSize;
+  } catch (err) {
+    if (isVersioned) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const lutWritable = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+      const lutReadonly = addressTableLookups.reduce((s, l) => s + l.readonlyIndexes.length, 0);
+      console.warn("[getTxSize] serialize failed", {
+        error: err.message,
+        staticKeys: staticAccountKeys.length,
+        numSignatures: header.numRequiredSignatures,
+        numLuts: addressTableLookups.length,
+        lutWritable,
+        lutReadonly,
+        totalAccounts: staticAccountKeys.length + lutWritable + lutReadonly
+      });
+    } else {
+      console.warn("[getTxSize] serialize failed", { error: err.message });
+    }
     return 9999;
   }
 }
@@ -14909,6 +14983,47 @@ function getAccountKeys(tx, lookupTableAccounts) {
     } else {
       return tx.compileMessage().getAccountKeys().length;
     }
+  } catch (err) {
+    console.warn("[getAccountKeys] decompile failed", { error: err.message });
+    return 9999;
+  }
+}
+function getWritableAccountKeys(tx) {
+  const isVersioned = isV0Tx(tx);
+  try {
+    if (isVersioned) {
+      const { header, staticAccountKeys, addressTableLookups } = tx.message;
+      const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
+      const writableLut = addressTableLookups.reduce(
+        (sum, lookup) => sum + lookup.writableIndexes.length,
+        0
+      );
+      return writableStatic + writableLut;
+    } else {
+      const message = tx.compileMessage();
+      const { numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts } = message.header;
+      const totalKeys = message.accountKeys.length;
+      const writableSigned = numRequiredSignatures - numReadonlySignedAccounts;
+      const writableUnsigned = totalKeys - numRequiredSignatures - numReadonlyUnsignedAccounts;
+      return writableSigned + writableUnsigned;
+    }
+  } catch {
+    return 9999;
+  }
+}
+function getTotalAccountKeys(tx) {
+  const isVersioned = isV0Tx(tx);
+  try {
+    if (isVersioned) {
+      const { staticAccountKeys, addressTableLookups } = tx.message;
+      const lutAccounts = addressTableLookups.reduce(
+        (sum, lookup) => sum + lookup.writableIndexes.length + lookup.readonlyIndexes.length,
+        0
+      );
+      return staticAccountKeys.length + lutAccounts;
+    } else {
+      return tx.compileMessage().accountKeys.length;
+    }
   } catch {
     return 9999;
   }
@@ -20146,6 +20261,14 @@ var HealthCacheSimulationError = class _HealthCacheSimulationError extends Error
   }
 };
 
+// src/services/account/types/action.types.ts
+var SwapProvider = /* @__PURE__ */ ((SwapProvider2) => {
+  SwapProvider2["JUPITER"] = "JUPITER";
+  SwapProvider2["TITAN"] = "TITAN";
+  SwapProvider2["DFLOW"] = "DFLOW";
+  return SwapProvider2;
+})(SwapProvider || {});
+
 // src/services/account/utils/deserialize.utils.ts
 var EMPTY_HEALTH_CACHE = {
   assetValue: {
@@ -44194,6 +44317,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 msgpack.Encoder({ useBigInt64: true });
+var decoder = new msgpack.Decoder({ useBigInt64: true });
+var V1Client = class _V1Client {
+  socket;
+  nextId = 0;
+  _closed = false;
+  _closing = false;
+  pending = /* @__PURE__ */ new Map();
+  streams = /* @__PURE__ */ new Map();
+  streamStopping = /* @__PURE__ */ new Map();
+  closeListeners = [];
+  // --- Static connect ---
+  static connect(url) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket__default.default(url, [SUBPROTOCOL]);
+      ws.binaryType = "arraybuffer";
+      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 web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(Buffer.from(ix.p, "base64")),
+    keys: ix.a.map((account) => ({
+      pubkey: new web3_js.PublicKey(Buffer.from(account.p, "base64")),
+      isSigner: account.s,
+      isWritable: account.w
+    })),
+    data: Buffer.from(ix.d, "base64")
+  });
+}
+function selectBestRoute(quotes, swapMode) {
+  const routes = Object.values(quotes);
+  if (routes.length === 0) return null;
+  return routes.reduce((best, route) => {
+    if (swapMode === "ExactIn") {
+      return route.outAmount > best.outAmount ? route : best;
+    } else {
+      return route.inAmount < best.inAmount ? route : best;
+    }
+  });
+}
+function buildSwapQuoteResult(route, swapMode) {
+  const slippageBps = route.slippageBps;
+  let otherAmountThreshold;
+  if (swapMode === "ExactIn") {
+    otherAmountThreshold = String(Math.floor(route.outAmount * (1 - slippageBps / 1e4)));
+  } else {
+    otherAmountThreshold = String(Math.ceil(route.inAmount * (1 + slippageBps / 1e4)));
+  }
+  return {
+    inAmount: String(route.inAmount),
+    outAmount: String(route.outAmount),
+    otherAmountThreshold,
+    slippageBps,
+    platformFee: route.platformFee ? {
+      amount: String(route.platformFee.amount),
+      feeBps: route.platformFee.fee_bps
+    } : void 0,
+    contextSlot: route.contextSlot,
+    timeTaken: route.timeTaken
+  };
+}
+async function resolveLookupTables(connection, lutPubkeys) {
+  if (lutPubkeys.length === 0) return [];
+  const lutAccountsRaw = await connection.getMultipleAccountsInfo(lutPubkeys);
+  return lutAccountsRaw.map((accountInfo, index) => {
+    if (!accountInfo) return null;
+    return new web3_js.AddressLookupTableAccount({
+      key: lutPubkeys[index],
+      state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
+    });
+  }).filter((account) => account !== null);
+}
 
 // src/vendor/klend/utils/klend/interest-rate.utils.ts
 function getKaminoTotalSupply(reserve) {
@@ -46483,116 +46930,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__default.default(endIndex) }
-  ) : await instructions_default.makeBeginFlashLoanIx(
+async function makeRepayIx3({
+  program,
+  bank,
+  tokenProgram,
+  amount,
+  authority,
+  accountAddress,
+  repayAll = false,
+  isSync = false,
+  opts = {}
+}) {
+  const wrapAndUnwrapSol = opts.wrapAndUnwrapSol ?? true;
+  const wSolBalanceUi = opts.wSolBalanceUi ?? 0;
+  const repayIxs = [];
+  const userAta = getAssociatedTokenAddressSync(bank.mint, authority, true, tokenProgram);
+  const remainingAccounts = tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? [{ pubkey: bank.mint, isSigner: false, isWritable: false }] : [];
+  if (bank.mint.equals(NATIVE_MINT) && wrapAndUnwrapSol) {
+    repayIxs.push(...makeWrapSolIxs(authority, new BigNumber3.BigNumber(amount).minus(wSolBalanceUi)));
+  }
+  const repayIx = !isSync || !opts.overrideInferAccounts?.group ? await instructions_default.makeRepayIx(
     program,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group,
+      liquidityVault: opts.overrideInferAccounts?.liquidityVault
     },
-    { endIndex: new BN11__default.default(endIndex) }
-  );
-  return { instructions: [ix], keys: [] };
-}
-async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
-  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
-  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
+  ) : sync_instructions_default.makeRepayIx(
     program.programId,
     {
-      marginfiAccount: marginfiAccountPk,
-      authority
-    },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
-  ) : await instructions_default.makeEndFlashLoanIx(
-    program,
-    {
-      marginfiAccount: marginfiAccountPk,
-      authority
+      marginfiAccount: accountAddress,
+      signerTokenAccount: userAta,
+      bank: bank.address,
+      tokenProgram,
+      authority: opts.overrideInferAccounts?.authority ?? authority,
+      group: opts.overrideInferAccounts?.group
     },
-    remainingAccounts.map((account) => ({
-      pubkey: account,
-      isSigner: false,
-      isWritable: false
-    }))
+    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
+    remainingAccounts
   );
-  return { instructions: [ix], keys: [] };
+  repayIxs.push(repayIx);
+  return {
+    instructions: repayIxs,
+    keys: []
+  };
 }
-async function makeFlashLoanTx({
-  program,
-  marginfiAccount,
-  ixs,
-  bankMap,
-  blockhash,
-  addressLookupTableAccounts,
-  signers,
-  isSync
-}) {
-  const endIndex = ixs.length + 1;
-  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
-    marginfiAccount.balances,
-    ixs,
-    program
-  );
-  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
-    const b = bankMap.get(account.toBase58());
-    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
-    return b;
-  });
-  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    endIndex,
-    marginfiAccount.authority,
-    isSync
-  );
-  const endFlashLoanIx = await makeEndFlashLoanIx3(
-    program,
-    marginfiAccount.address,
-    projectedActiveBanks,
-    marginfiAccount.authority,
-    isSync
-  );
-  const message = new web3_js.TransactionMessage({
-    payerKey: marginfiAccount.authority,
-    recentBlockhash: blockhash,
-    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
-  }).compileToV0Message(addressLookupTableAccounts);
-  const tx = addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-    addressLookupTables: addressLookupTableAccounts,
-    type: "FLASHLOAN" /* FLASHLOAN */,
-    signers
+async function makeRepayTx(params) {
+  const { luts, ...depositIxParams } = params;
+  const ixs = await makeRepayIx3(depositIxParams);
+  const tx = new web3_js.Transaction().add(...ixs.instructions);
+  tx.feePayer = params.authority;
+  const solanaTx = addTransactionMetadata(tx, {
+    type: "REPAY" /* REPAY */,
+    signers: ixs.keys,
+    addressLookupTables: luts
   });
-  if (signers) {
-    tx.sign(signers);
-  }
-  return tx;
+  return solanaTx;
 }
-
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
+async function makeRepayWithCollatTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    depositOpts,
-    borrowOpts,
+    withdrawOpts,
+    repayOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
+    crossbarUrl
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -46600,34 +47012,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
   });
@@ -46637,7 +47049,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;
       }
     }
@@ -46649,24 +47061,18 @@ async function makeLoopTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    instructions: [...withdrawIxs.instructions, ...repayIxs.instructions],
     program,
     connection,
     crossbarUrl
   });
   let additionalTxs = [];
-  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
-    setupIxs.push(
-      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber3.BigNumber(depositOpts.inputDepositAmount))
-    );
-  }
-  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
+  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
     const ixs = [
-      ...additionalIxs,
       ...setupIxs,
       ...kaminoRefreshIxs.instructions,
       ...updateDriftMarketIxs.instructions,
-      ...updateJupLendRateIxs.instructions
+      ...updateJuplendMarketIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -46696,300 +47102,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 = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.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 web3_js.PublicKey(depositOpts.depositBank.mint),
+      new web3_js.PublicKey(repayOpts.repayBank.mint),
       marginfiAccount.authority,
       true,
-      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const 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 BigNumber3.BigNumber(1);
+      const adjustedAmount = new BigNumber3.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 BigNumber3.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__default.default(endIndex) }
+  );
+  const endFlRemainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const endFlIx = sync_instructions_default.makeEndFlashLoanIx(
+    program.programId,
+    { marginfiAccount: marginfiAccount.address, authority: marginfiAccount.authority },
+    endFlRemainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false }))
+  );
+  const allNonSwapIxs = [beginFlIx, ...ixs, endFlIx];
+  const nonSwapMsg = new web3_js.TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: web3_js.PublicKey.default.toBase58(),
+    instructions: allNonSwapIxs
+  }).compileToV0Message(addressLookupTableAccounts);
+  const nonSwapSize = new web3_js.VersionedTransaction(nonSwapMsg).serialize().length;
+  const { header, staticAccountKeys, addressTableLookups } = nonSwapMsg;
+  const nonSwapTotal = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  const sizeConstraint = MAX_TX_SIZE - nonSwapSize - SWAP_MERGE_OVERHEAD;
+  const maxSwapTotalAccounts = MAX_ACCOUNT_LOCKS - nonSwapTotal;
+  console.log("[flashloan-budget]", {
+    method: "compiled",
+    nonSwapSize,
+    nonSwapTotal,
+    sizeConstraint,
+    maxSwapTotalAccounts
+  });
+  return { sizeConstraint, maxSwapTotalAccounts };
+}
+function compileFlashloanPrecheck({
+  allIxs,
+  payer,
+  luts,
+  sizeConstraint,
+  swapIxCount,
+  swapLutCount
+}) {
+  const msg = new web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: web3_js.PublicKey.default.toBase58(),
+    instructions: allIxs
+  }).compileToV0Message(luts);
+  const rawSize = new web3_js.VersionedTransaction(msg).serialize().length;
+  const fullTxSize = rawSize + FL_IX_OVERHEAD;
+  const overshoot = fullTxSize - MAX_TX_SIZE;
+  const { header, staticAccountKeys, addressTableLookups } = msg;
+  const writableStatic = staticAccountKeys.length - header.numReadonlySignedAccounts - header.numReadonlyUnsignedAccounts;
+  const writableLut = addressTableLookups.reduce((s, l) => s + l.writableIndexes.length, 0);
+  const writableAccounts = writableStatic + writableLut;
+  const totalAccounts = staticAccountKeys.length + addressTableLookups.reduce(
+    (s, l) => s + l.writableIndexes.length + l.readonlyIndexes.length,
+    0
+  );
+  console.log("[flashloan-precheck]", {
+    fullTxSize,
+    overshoot,
+    sizeConstraint,
+    writableAccounts,
+    totalAccounts,
+    staticKeys: staticAccountKeys.length,
+    numLuts: addressTableLookups.length,
+    swapIxCount,
+    swapLutCount
+  });
+  return { fullTxSize, overshoot, writableAccounts, totalAccounts };
+}
+async function buildBudgetIx(config, program, marginfiAccount, bankMap, bankMetadataMap, overrideInferAccounts) {
+  const { bank, tokenProgram } = config;
+  switch (config.type) {
+    case "borrow":
+      return makeBorrowIx3({
+        program,
+        bank,
+        bankMap,
+        tokenProgram,
+        amount: 1,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        isSync: true,
+        opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "repay":
+      return makeRepayIx3({
+        program,
+        bank,
+        tokenProgram,
+        amount: 1,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        repayAll: false,
+        isSync: true,
+        opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+      });
+    case "deposit":
+      return buildDepositBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
+    case "withdraw":
+      return buildWithdrawBudgetIx(
+        config,
+        program,
+        marginfiAccount,
+        bankMap,
+        bankMetadataMap,
+        overrideInferAccounts
+      );
   }
-  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 = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const [primaryResult, secondaryResult] = await Promise.all([
+    buildBudgetIx(
+      primaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    ),
+    buildBudgetIx(
+      secondaryIx,
+      program,
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      overrideInferAccounts
+    )
+  ]);
+  return computeFlashLoanNonSwapBudget({
     program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts,
+    ixs: [...cuRequestIxs, ...primaryResult.instructions, ...secondaryResult.instructions]
+  });
+}
+
+// src/services/account/actions/flash-loan.ts
+async function makeBeginFlashLoanIx3(program, marginfiAccountPk, endIndex, authority, isSync) {
+  const ix = isSync && authority ? sync_instructions_default.makeBeginFlashLoanIx(
+    program.programId,
     {
-      marginfiAccount: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group,
-      liquidityVault: opts.overrideInferAccounts?.liquidityVault
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
-  ) : sync_instructions_default.makeRepayIx(
+    { endIndex: new BN11__default.default(endIndex) }
+  ) : await instructions_default.makeBeginFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    { endIndex: new BN11__default.default(endIndex) }
+  );
+  return { instructions: [ix], keys: [] };
+}
+async function makeEndFlashLoanIx3(program, marginfiAccountPk, projectedActiveBanks, authority, isSync) {
+  const remainingAccounts = computeHealthAccountMetas(projectedActiveBanks);
+  const ix = isSync && authority ? sync_instructions_default.makeEndFlashLoanIx(
     program.programId,
     {
-      marginfiAccount: accountAddress,
-      signerTokenAccount: userAta,
-      bank: bank.address,
-      tokenProgram,
-      authority: opts.overrideInferAccounts?.authority ?? authority,
-      group: opts.overrideInferAccounts?.group
+      marginfiAccount: marginfiAccountPk,
+      authority
     },
-    { amount: uiToNative(amount, bank.mintDecimals), repayAll },
-    remainingAccounts
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
+  ) : await instructions_default.makeEndFlashLoanIx(
+    program,
+    {
+      marginfiAccount: marginfiAccountPk,
+      authority
+    },
+    remainingAccounts.map((account) => ({
+      pubkey: account,
+      isSigner: false,
+      isWritable: false
+    }))
   );
-  repayIxs.push(repayIx);
-  return {
-    instructions: repayIxs,
-    keys: []
-  };
+  return { instructions: [ix], keys: [] };
 }
-async function makeRepayTx(params) {
-  const { luts, ...depositIxParams } = params;
-  const ixs = await makeRepayIx3(depositIxParams);
-  const tx = new web3_js.Transaction().add(...ixs.instructions);
-  tx.feePayer = params.authority;
-  const solanaTx = addTransactionMetadata(tx, {
-    type: "REPAY" /* REPAY */,
-    signers: ixs.keys,
-    addressLookupTables: luts
+async function makeFlashLoanTx({
+  program,
+  marginfiAccount,
+  ixs,
+  bankMap,
+  blockhash,
+  addressLookupTableAccounts,
+  signers,
+  isSync
+}) {
+  const endIndex = ixs.length + 1;
+  const projectedActiveBanksKeys = computeProjectedActiveBanksNoCpi(
+    marginfiAccount.balances,
+    ixs,
+    program
+  );
+  const projectedActiveBanks = projectedActiveBanksKeys.map((account) => {
+    const b = bankMap.get(account.toBase58());
+    if (!b) throw Error(`Bank ${account.toBase58()} not found, in makeFlashLoanTx function`);
+    return b;
   });
-  return solanaTx;
+  const beginFlashLoanIx = await makeBeginFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    endIndex,
+    marginfiAccount.authority,
+    isSync
+  );
+  const endFlashLoanIx = await makeEndFlashLoanIx3(
+    program,
+    marginfiAccount.address,
+    projectedActiveBanks,
+    marginfiAccount.authority,
+    isSync
+  );
+  const message = new web3_js.TransactionMessage({
+    payerKey: marginfiAccount.authority,
+    recentBlockhash: blockhash,
+    instructions: [...beginFlashLoanIx.instructions, ...ixs, ...endFlashLoanIx.instructions]
+  }).compileToV0Message(addressLookupTableAccounts);
+  const tx = addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+    addressLookupTables: addressLookupTableAccounts,
+    type: "FLASHLOAN" /* FLASHLOAN */,
+    signers
+  });
+  if (signers) {
+    tx.sign(signers);
+  }
+  return tx;
 }
-async function makeRepayWithCollatTx(params) {
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
   const {
     program,
     marginfiAccount,
     bankMap,
-    withdrawOpts,
-    repayOpts,
+    depositOpts,
+    borrowOpts,
     bankMetadataMap,
     addressLookupTableAccounts,
     connection,
     oraclePrices,
-    crossbarUrl
+    crossbarUrl,
+    additionalIxs = []
   } = params;
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const setupIxs = await makeSetupIx({
@@ -46997,34 +47938,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
   });
@@ -47034,7 +47975,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;
       }
     }
@@ -47046,18 +47987,24 @@ async function makeRepayWithCollatTx(params) {
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...withdrawIxs.instructions, ...repayIxs.instructions],
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
     program,
     connection,
     crossbarUrl
   });
   let additionalTxs = [];
-  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJuplendMarketIxs.instructions.length > 0) {
+  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
+    setupIxs.push(
+      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber3.BigNumber(depositOpts.inputDepositAmount))
+    );
+  }
+  if (setupIxs.length > 0 || additionalIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0 || updateJupLendRateIxs.instructions.length > 0) {
     const ixs = [
+      ...additionalIxs,
       ...setupIxs,
       ...kaminoRefreshIxs.instructions,
       ...updateDriftMarketIxs.instructions,
-      ...updateJuplendMarketIxs.instructions
+      ...updateJupLendRateIxs.instructions
     ];
     const txs = splitInstructionsToFitTransactions([], ixs, {
       blockhash,
@@ -47087,110 +48034,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 = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.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 web3_js.PublicKey(repayOpts.repayBank.mint),
+      new web3_js.PublicKey(depositOpts.depositBank.mint),
       marginfiAccount.authority,
       true,
-      repayOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+      depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
     );
-    const 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 BigNumber3.BigNumber(1);
-      const adjustedAmount = new BigNumber3.BigNumber(withdrawOpts.withdrawAmount).div(multiplier).times(1.0001).toNumber();
-      withdrawIxs = await makeKaminoWithdrawIx3({
+      depositIxs = await makeKaminoDepositIx3({
         program,
-        bank: withdrawOpts.withdrawBank,
-        bankMap,
-        tokenProgram: withdrawOpts.tokenProgram,
-        cTokenAmount: adjustedAmount,
-        marginfiAccount,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountToDeposit,
+        accountAddress: marginfiAccount.address,
         authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
         reserve,
-        withdrawAll: isWholePosition(
-          {
-            amount: withdrawOpts.totalPositionAmount,
-            isLending: true
-          },
-          withdrawOpts.withdrawAmount,
-          withdrawOpts.withdrawBank.mintDecimals
-        ),
-        isSync: false,
         opts: {
-          createAtas: false,
           wrapAndUnwrapSol: false,
           overrideInferAccounts
         }
@@ -47198,35 +48156,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
         }
@@ -47234,33 +48184,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
         }
@@ -47268,25 +48200,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
         }
@@ -47294,68 +48216,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
@@ -47509,11 +48411,16 @@ async function buildSwapCollateralFlashloanTx({
     actualWithdrawAmount,
     withdrawBank.mintDecimals
   );
-  const swapResult = [];
   const cuRequestIxs = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
   ];
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
   let withdrawIxs;
   switch (withdrawOpts.withdrawBank.config.assetTag) {
     case 3 /* KAMINO */: {
@@ -47623,12 +48530,7 @@ async function buildSwapCollateralFlashloanTx({
     }
   }
   if (depositBank.mint.equals(withdrawBank.mint)) {
-    swapResult.push({
-      amountToDeposit: actualWithdrawAmount,
-      swapInstructions: [],
-      setupInstructions: [],
-      swapLookupTables: []
-    });
+    amountToDeposit = actualWithdrawAmount;
   } else {
     const destinationTokenAccount = getAssociatedTokenAddressSync(
       depositBank.mint,
@@ -47636,175 +48538,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 {
@@ -47942,7 +48837,6 @@ async function buildSwapDebtFlashloanTx({
     throw new Error("repayAmount must be greater than 0");
   }
   const actualRepayAmount = Math.min(repayAmount ?? totalPositionAmount, totalPositionAmount);
-  const swapResult = [];
   const cuRequestIxs = [
     web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
     web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
@@ -47953,140 +48847,120 @@ async function buildSwapDebtFlashloanTx({
     true,
     repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
   );
-  const jupiterApiClient = swapOpts.jupiterOptions?.configParams?.basePath ? new api.SwapApi(new api.Configuration(swapOpts.jupiterOptions.configParams)) : api.createJupiterApiClient(swapOpts.jupiterOptions?.configParams);
-  const estimateQuote = await jupiterApiClient.quoteGet({
+  const { otherAmountThreshold } = await getExactOutEstimate({
     inputMint: borrowBank.mint.toBase58(),
     outputMint: repayBank.mint.toBase58(),
     amount: uiToNative(actualRepayAmount, repayBank.mintDecimals).toNumber(),
-    swapMode: "ExactOut",
-    dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-    slippageBps: swapOpts.jupiterOptions?.slippageBps
+    swapOpts,
+    connection
   });
-  const estimatedBorrowAmount = nativeToUi(
-    estimateQuote.otherAmountThreshold,
-    borrowBank.mintDecimals
-  );
-  const swapResponses = await getJupiterSwapIxsForFlashloan({
-    quoteParams: {
-      inputMint: borrowBank.mint.toBase58(),
-      outputMint: repayBank.mint.toBase58(),
-      amount: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
-      dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
-      slippageBps: swapOpts.jupiterOptions?.slippageBps,
-      swapMode: "ExactIn",
-      platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps,
-      onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
-    },
+  const estimatedBorrowAmount = nativeToUi(otherAmountThreshold, borrowBank.mintDecimals);
+  const swapConstraints = await computeFlashloanSwapConstraints({
+    program,
+    marginfiAccount,
+    bankMap,
+    bankMetadataMap,
+    addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+    primaryIx: { type: "borrow", bank: borrowBank, tokenProgram: borrowTokenProgram },
+    secondaryIx: { type: "repay", bank: repayBank, tokenProgram: repayTokenProgram },
+    overrideInferAccounts
+  });
+  const swapResponses = await getSwapIxsForFlashloan({
+    inputMint: borrowBank.mint.toBase58(),
+    outputMint: repayBank.mint.toBase58(),
+    amount: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
+    swapMode: "ExactIn",
     authority: marginfiAccount.authority,
     connection,
     destinationTokenAccount,
-    configParams: swapOpts.jupiterOptions?.configParams
+    swapOpts,
+    sizeConstraint: swapConstraints.sizeConstraint,
+    maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
   });
-  swapResponses.forEach((response) => {
-    const outAmount = nativeToUi(response.quoteResponse.outAmount, repayBank.mintDecimals);
-    const outAmountThreshold = nativeToUi(
-      response.quoteResponse.otherAmountThreshold,
-      repayBank.mintDecimals
-    );
-    const amountToRepay = outAmount > totalPositionAmount ? totalPositionAmount : outAmountThreshold;
-    const borrowAmount = nativeToUi(response.quoteResponse.inAmount, borrowBank.mintDecimals);
-    swapResult.push({
-      amountToRepay,
-      borrowAmount,
-      swapInstructions: [response.swapInstruction],
-      setupInstructions: response.setupInstructions,
-      swapLookupTables: response.addressLookupTableAddresses,
-      quoteResponse: response.quoteResponse
-    });
+  const { quoteResponse } = swapResponses;
+  const outAmount = nativeToUi(quoteResponse.outAmount, repayBank.mintDecimals);
+  const outAmountThreshold = nativeToUi(quoteResponse.otherAmountThreshold, repayBank.mintDecimals);
+  const amountToRepay = outAmount > totalPositionAmount ? totalPositionAmount : outAmountThreshold;
+  const borrowAmount = nativeToUi(quoteResponse.inAmount, borrowBank.mintDecimals);
+  const borrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowBank,
+    bankMap,
+    tokenProgram: borrowTokenProgram,
+    amount: borrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: true,
+    opts: {
+      createAtas: false,
+      wrapAndUnwrapSol: false,
+      overrideInferAccounts
+    }
   });
-  if (swapResult.length === 0) {
-    throw new Error(
-      `No swap routes found for ${borrowBank.mint.toBase58()} -> ${repayBank.mint.toBase58()}`
-    );
-  }
-  for (const [index, item] of swapResult.entries()) {
-    const {
+  const repayIxs = await makeRepayIx3({
+    program,
+    bank: repayBank,
+    tokenProgram: repayTokenProgram,
+    amount: amountToRepay,
+    accountAddress: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    repayAll: isWholePosition(
+      {
+        amount: totalPositionAmount,
+        isLending: false
+      },
       amountToRepay,
-      borrowAmount,
-      swapInstructions,
-      setupInstructions,
-      swapLookupTables,
-      quoteResponse
-    } = item;
-    const borrowIxs = await makeBorrowIx3({
-      program,
-      bank: borrowBank,
-      bankMap,
-      tokenProgram: borrowTokenProgram,
-      amount: borrowAmount,
-      marginfiAccount,
-      authority: marginfiAccount.authority,
-      isSync: true,
-      opts: {
-        createAtas: false,
-        wrapAndUnwrapSol: false,
-        overrideInferAccounts
-      }
-    });
-    const repayIxs = await makeRepayIx3({
-      program,
-      bank: repayBank,
-      tokenProgram: repayTokenProgram,
-      amount: amountToRepay,
-      accountAddress: marginfiAccount.address,
-      authority: marginfiAccount.authority,
-      repayAll: isWholePosition(
-        {
-          amount: totalPositionAmount,
-          isLending: false
-        },
-        amountToRepay,
-        repayBank.mintDecimals
-      ),
-      isSync: true,
-      opts: {
-        wrapAndUnwrapSol: false,
-        overrideInferAccounts
-      }
-    });
-    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
-    const flashloanParams = {
-      program,
-      marginfiAccount,
-      bankMap,
-      addressLookupTableAccounts: luts,
-      blockhash
-    };
-    const flashloanTx = await makeFlashLoanTx({
-      ...flashloanParams,
-      ixs: [
-        ...cuRequestIxs,
-        ...borrowIxs.instructions,
-        ...swapInstructions,
-        ...repayIxs.instructions
-      ],
-      isSync: true
-    });
-    const txSize = getTxSize(flashloanTx);
-    const keySize = getAccountKeys(flashloanTx, luts);
-    const isLast = index === swapResult.length - 1;
-    if (txSize > MAX_TX_SIZE || keySize > 64) {
-      if (isLast) {
-        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
-      } else {
-        continue;
-      }
-    } else {
-      return {
-        flashloanTx,
-        setupInstructions,
-        swapQuote: quoteResponse,
-        borrowIxs,
-        repayIxs
-      };
+      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 web3_js.PublicKey("SysvarC1ock11111111111111111111111111111111");
 async function makeMintStakedLstIx(params) {
@@ -48885,17 +49759,528 @@ function computeMaxWithdrawForBank(params) {
   const maxWithdraw = initUntiedCollateralForBank.div(initWeightedPrice);
   return maxWithdraw;
 }
+var TITAN_FEE_WALLET = new web3_js.PublicKey("6ryqDDCwKFZfSiHQrYRkjTEarbsLjg9TmuFg1RJorBk3");
+var getTitanFeeAccount = (mint) => {
+  return getAssociatedTokenAddressSync(mint, TITAN_FEE_WALLET, true);
+};
+var checkTitanFeeAccount = async (connection, mint) => {
+  const feeAccount = getTitanFeeAccount(mint);
+  const hasFeeAccount = !!await connection.getAccountInfo(feeAccount);
+  return { feeAccount, hasFeeAccount, feeWallet: TITAN_FEE_WALLET };
+};
+function deserializeTitanInstruction(ix) {
+  return new web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(ix.p),
+    keys: ix.a.map((account) => ({
+      pubkey: new web3_js.PublicKey(account.p),
+      isSigner: account.s,
+      isWritable: account.w
+    })),
+    data: Buffer.from(ix.d)
+  });
+}
+var getTitanSwapIxsForFlashloan = async ({
+  quoteParams,
+  authority,
+  connection,
+  destinationTokenAccount,
+  apiConfig
+}) => {
+  const basePath = apiConfig?.basePath ?? "";
+  const feeMint = new web3_js.PublicKey(
+    quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint
+  );
+  const { feeAccount, hasFeeAccount } = await checkTitanFeeAccount(connection, feeMint);
+  let finalQuoteParams = quoteParams;
+  if (!hasFeeAccount) {
+    console.warn("Warning: Titan fee account ATA does not exist, disabling platform fee");
+    finalQuoteParams = {
+      ...quoteParams,
+      platformFeeBps: void 0
+    };
+  }
+  if (basePath.startsWith("wss://") || basePath.startsWith("ws://")) {
+    return getTitanSwapIxsViaWebSocket(
+      { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
+      hasFeeAccount ? feeAccount : void 0
+    );
+  } else {
+    return getTitanSwapIxsViaHttpProxy(
+      { quoteParams: finalQuoteParams, authority, connection, destinationTokenAccount, apiConfig },
+      hasFeeAccount ? feeAccount : void 0
+    );
+  }
+};
+async function getTitanSwapIxsViaWebSocket(params, feeAccount) {
+  const { quoteParams, authority, connection, destinationTokenAccount, apiConfig } = params;
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    slippageBps,
+    platformFeeBps,
+    directRoutesOnly,
+    sizeConstraint,
+    maxSwapAccounts,
+    maxSwapTotalAccounts
+  } = quoteParams;
+  const wsUrl = apiConfig?.basePath;
+  if (!wsUrl) {
+    throw new Error("Titan WebSocket URL is required (apiConfig.basePath)");
+  }
+  const txParams = {
+    userPublicKey: authority.toBytes(),
+    outputAccount: destinationTokenAccount.toBytes()
+  };
+  if (feeAccount && platformFeeBps) {
+    txParams.feeBps = platformFeeBps;
+    txParams.feeAccount = feeAccount.toBytes();
+  }
+  const client = await V1Client.connect(wsUrl);
+  try {
+    const { stream } = await client.newSwapQuoteStream({
+      swap: {
+        inputMint: new web3_js.PublicKey(inputMint).toBytes(),
+        outputMint: new web3_js.PublicKey(outputMint).toBytes(),
+        amount,
+        swapMode,
+        slippageBps,
+        onlyDirectRoutes: directRoutesOnly,
+        addSizeConstraint: sizeConstraint !== void 0,
+        sizeConstraint,
+        accountsLimitWritable: maxSwapAccounts,
+        accountsLimitTotal: maxSwapTotalAccounts
+      },
+      transaction: txParams,
+      update: {
+        num_quotes: 3
+      }
+    });
+    const reader = stream.getReader();
+    const { value: swapQuotes, done } = await reader.read();
+    reader.releaseLock();
+    if (done || !swapQuotes) {
+      throw new Error("Titan swap quote stream ended without data");
+    }
+    const quotes = swapQuotes;
+    const bestRoute = selectBestRoute(quotes.quotes, swapMode);
+    if (!bestRoute) {
+      throw new Error(`No Titan swap routes found for ${inputMint} -> ${outputMint}`);
+    }
+    const swapInstructions = bestRoute.instructions.map(deserializeTitanInstruction);
+    const lutPubkeys = bestRoute.addressLookupTables.map((lutBytes) => new web3_js.PublicKey(lutBytes));
+    const addressLookupTableAddresses = await resolveLookupTables(connection, lutPubkeys);
+    const quoteResponse = {
+      ...buildSwapQuoteResult(bestRoute, swapMode),
+      provider: "TITAN" /* TITAN */
+    };
+    return {
+      swapInstructions,
+      setupInstructions: [],
+      addressLookupTableAddresses,
+      quoteResponse
+    };
+  } finally {
+    if (!client.closed) {
+      await client.close();
+    }
+  }
+}
+async function getTitanSwapIxsViaHttpProxy(params, feeAccount) {
+  const { quoteParams, authority, connection, destinationTokenAccount, apiConfig } = params;
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    slippageBps,
+    platformFeeBps,
+    directRoutesOnly,
+    sizeConstraint,
+    maxSwapAccounts,
+    maxSwapTotalAccounts
+  } = quoteParams;
+  const basePath = apiConfig?.basePath;
+  if (!basePath) {
+    throw new Error("Titan proxy URL is required (apiConfig.basePath)");
+  }
+  const txBody = {
+    userPublicKey: authority.toBase58(),
+    outputAccount: destinationTokenAccount.toBase58()
+  };
+  if (feeAccount && platformFeeBps) {
+    txBody.feeBps = platformFeeBps;
+    txBody.feeAccount = feeAccount.toBase58();
+  }
+  const response = await fetch(`${basePath}/swap-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiConfig?.headers ?? {}
+    },
+    body: JSON.stringify({
+      swap: {
+        inputMint,
+        outputMint,
+        amount,
+        swapMode,
+        slippageBps,
+        onlyDirectRoutes: directRoutesOnly,
+        addSizeConstraint: sizeConstraint !== void 0,
+        sizeConstraint,
+        accountsLimitWritable: maxSwapAccounts,
+        accountsLimitTotal: maxSwapTotalAccounts
+      },
+      transaction: txBody
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(
+      `Titan proxy error (${response.status}): ${errorData.message ?? response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const bestRoute = selectBestRoute(data.quotes, swapMode);
+  if (!bestRoute) {
+    throw new Error(`No Titan swap routes found for ${inputMint} -> ${outputMint}`);
+  }
+  const swapInstructions = bestRoute.instructions.map(deserializeSerializedInstruction);
+  const lutPubkeys = bestRoute.addressLookupTables.map(
+    (b64) => new web3_js.PublicKey(Buffer.from(b64, "base64"))
+  );
+  const addressLookupTableAddresses = await resolveLookupTables(connection, lutPubkeys);
+  const quoteResponse = {
+    ...buildSwapQuoteResult(bestRoute, swapMode),
+    provider: "TITAN" /* TITAN */
+  };
+  return {
+    swapInstructions,
+    setupInstructions: [],
+    addressLookupTableAddresses,
+    quoteResponse
+  };
+}
+var getTitanExactOutEstimate = async (params) => {
+  const basePath = params.apiConfig?.basePath ?? "";
+  if (basePath.startsWith("wss://") || basePath.startsWith("ws://")) {
+    return getTitanExactOutViaWebSocket(params);
+  } else {
+    return getTitanExactOutViaHttpProxy(params);
+  }
+};
+async function getTitanExactOutViaWebSocket(params) {
+  const { inputMint, outputMint, amount, slippageBps, apiConfig } = params;
+  const wsUrl = apiConfig?.basePath;
+  if (!wsUrl) {
+    throw new Error("Titan WebSocket URL is required (apiConfig.basePath)");
+  }
+  const client = await V1Client.connect(wsUrl);
+  try {
+    const { stream } = await client.newSwapQuoteStream({
+      swap: {
+        inputMint: new web3_js.PublicKey(inputMint).toBytes(),
+        outputMint: new web3_js.PublicKey(outputMint).toBytes(),
+        amount,
+        swapMode: "ExactOut",
+        slippageBps
+      },
+      transaction: {
+        userPublicKey: new Uint8Array(32)
+        // placeholder, not executing
+      },
+      update: {
+        num_quotes: 1
+      }
+    });
+    const reader = stream.getReader();
+    const { value: swapQuotes, done } = await reader.read();
+    reader.releaseLock();
+    if (done || !swapQuotes) {
+      throw new Error("Titan ExactOut estimate stream ended without data");
+    }
+    const quotes = swapQuotes;
+    const bestRoute = selectBestRoute(quotes.quotes, "ExactOut");
+    if (!bestRoute) {
+      throw new Error(`No Titan ExactOut routes found for ${inputMint} -> ${outputMint}`);
+    }
+    const quoteResult = {
+      ...buildSwapQuoteResult(bestRoute, "ExactOut"),
+      provider: "TITAN" /* TITAN */
+    };
+    return {
+      otherAmountThreshold: quoteResult.otherAmountThreshold,
+      quoteResult
+    };
+  } finally {
+    if (!client.closed) {
+      await client.close();
+    }
+  }
+}
+async function getTitanExactOutViaHttpProxy(params) {
+  const { inputMint, outputMint, amount, slippageBps, apiConfig } = params;
+  const basePath = apiConfig?.basePath;
+  if (!basePath) {
+    throw new Error("Titan proxy URL is required (apiConfig.basePath)");
+  }
+  const response = await fetch(`${basePath}/exact-out-estimate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiConfig?.headers ?? {}
+    },
+    body: JSON.stringify({
+      inputMint,
+      outputMint,
+      amount,
+      slippageBps
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(
+      `Titan proxy error (${response.status}): ${errorData.message ?? response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const quoteResult = {
+    inAmount: String(data.inAmount),
+    outAmount: String(data.outAmount),
+    otherAmountThreshold: data.otherAmountThreshold,
+    slippageBps: data.slippageBps,
+    provider: "TITAN" /* TITAN */
+  };
+  return {
+    otherAmountThreshold: data.otherAmountThreshold,
+    quoteResult
+  };
+}
+
+// src/services/account/utils/swap.utils.ts
+function getSwapProviderFn({
+  attemptProvider,
+  maxSwapTotalAccounts,
+  inputMint,
+  outputMint,
+  amount,
+  swapMode,
+  authority,
+  connection,
+  destinationTokenAccount,
+  swapOpts,
+  sizeConstraint
+}) {
+  switch (attemptProvider) {
+    case "TITAN" /* TITAN */:
+      return (apiConfig) => getTitanSwapIxsForFlashloan({
+        quoteParams: {
+          inputMint,
+          outputMint,
+          amount,
+          swapMode,
+          slippageBps: swapOpts.swapConfig?.slippageBps,
+          platformFeeBps: swapOpts.swapConfig?.platformFeeBps,
+          directRoutesOnly: swapOpts.swapConfig?.directRoutesOnly,
+          sizeConstraint,
+          maxSwapTotalAccounts
+        },
+        authority,
+        connection,
+        destinationTokenAccount,
+        apiConfig
+      });
+    case "JUPITER" /* JUPITER */:
+      return (apiConfig) => getJupiterSwapIxsForFlashloan({
+        quoteParams: {
+          inputMint,
+          outputMint,
+          amount,
+          swapMode,
+          dynamicSlippage: swapOpts.swapConfig ? swapOpts.swapConfig.slippageMode === "DYNAMIC" : true,
+          slippageBps: swapOpts.swapConfig?.slippageBps,
+          platformFeeBps: swapOpts.swapConfig?.platformFeeBps,
+          onlyDirectRoutes: swapOpts.swapConfig?.directRoutesOnly ?? false
+        },
+        authority,
+        connection,
+        destinationTokenAccount,
+        apiConfig,
+        maxSwapAccounts: maxSwapTotalAccounts
+      });
+    default:
+      return void 0;
+  }
+}
+function getExactOutProviderFn({
+  attemptProvider,
+  inputMint,
+  outputMint,
+  amount,
+  swapOpts,
+  apiConfig
+}) {
+  switch (attemptProvider) {
+    case "TITAN" /* TITAN */:
+      return () => getTitanExactOutEstimate({
+        inputMint,
+        outputMint,
+        amount,
+        slippageBps: swapOpts.swapConfig?.slippageBps,
+        apiConfig
+      });
+    case "JUPITER" /* JUPITER */:
+      return async () => {
+        const configParams = toJupiterConfig(apiConfig);
+        const jupiterApiClient = configParams?.basePath ? new api.SwapApi(new api.Configuration(configParams)) : api.createJupiterApiClient(configParams);
+        const estimateQuote = await jupiterApiClient.quoteGet({
+          inputMint,
+          outputMint,
+          amount,
+          swapMode: "ExactOut",
+          dynamicSlippage: swapOpts.swapConfig ? swapOpts.swapConfig.slippageMode === "DYNAMIC" : true,
+          slippageBps: swapOpts.swapConfig?.slippageBps
+        });
+        const quoteResult = mapJupiterQuoteToSwapQuoteResult(estimateQuote);
+        return { otherAmountThreshold: quoteResult.otherAmountThreshold, quoteResult };
+      };
+    default:
+      return void 0;
+  }
+}
+var getSwapIxsForFlashloan = async (params) => {
+  const {
+    inputMint,
+    outputMint,
+    amount,
+    swapMode,
+    authority,
+    connection,
+    destinationTokenAccount,
+    swapOpts,
+    sizeConstraint,
+    maxSwapTotalAccounts
+  } = params;
+  if (swapOpts.swapIxs) {
+    return {
+      swapInstructions: swapOpts.swapIxs.instructions,
+      setupInstructions: [],
+      addressLookupTableAddresses: swapOpts.swapIxs.lookupTables,
+      quoteResponse: {
+        inAmount: String(amount),
+        outAmount: "0",
+        otherAmountThreshold: "0",
+        slippageBps: 0
+      }
+    };
+  }
+  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
+  const attempts = [
+    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
+    ...swapOpts.swapConfig?.fallbackProviders ?? []
+  ];
+  let lastError;
+  for (const { provider: attemptProvider, apiConfig } of attempts) {
+    const fn = getSwapProviderFn({
+      attemptProvider,
+      maxSwapTotalAccounts: params.maxSwapTotalAccounts,
+      inputMint,
+      outputMint,
+      amount,
+      swapMode,
+      authority,
+      connection,
+      destinationTokenAccount,
+      swapOpts,
+      sizeConstraint
+    });
+    if (!fn) continue;
+    try {
+      return await fn(apiConfig);
+    } catch (err) {
+      if (err instanceof TransactionBuildingError) throw err;
+      lastError = err;
+      console.warn(`[swap] ${attemptProvider} failed:`, err instanceof Error ? err.message : err);
+    }
+  }
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+var getExactOutEstimate = async (params) => {
+  const { inputMint, outputMint, amount, swapOpts, connection } = params;
+  const provider = swapOpts.swapConfig?.provider ?? "JUPITER" /* JUPITER */;
+  const attempts = [
+    { provider, apiConfig: swapOpts.swapConfig?.apiConfig },
+    ...swapOpts.swapConfig?.fallbackProviders ?? []
+  ];
+  let lastError;
+  for (const { provider: attemptProvider, apiConfig } of attempts) {
+    const fn = getExactOutProviderFn({
+      attemptProvider,
+      inputMint,
+      outputMint,
+      amount,
+      swapOpts,
+      apiConfig
+    });
+    if (!fn) continue;
+    try {
+      return await fn(apiConfig);
+    } catch (err) {
+      if (err instanceof TransactionBuildingError) throw err;
+      lastError = err;
+      console.warn(
+        `[exactout] ${attemptProvider} failed:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  const firstProvider = attempts[0]?.provider ?? "Swap";
+  throw TransactionBuildingError.swapQuoteFailed(
+    firstProvider,
+    inputMint,
+    outputMint,
+    lastError?.message ?? "No swap route available"
+  );
+};
+function mapJupiterQuoteToSwapQuoteResult(quote) {
+  return {
+    inAmount: quote.inAmount,
+    outAmount: quote.outAmount,
+    otherAmountThreshold: quote.otherAmountThreshold,
+    slippageBps: quote.slippageBps,
+    platformFee: quote.platformFee ? {
+      amount: quote.platformFee.amount ?? "0",
+      feeBps: quote.platformFee.feeBps ?? 0
+    } : void 0,
+    priceImpactPct: quote.priceImpactPct,
+    contextSlot: quote.contextSlot,
+    timeTaken: quote.timeTaken,
+    provider: "JUPITER" /* JUPITER */
+  };
+}
+
+// src/services/account/utils/jupiter.utils.ts
 var REFERRAL_PROGRAM_ID = new web3_js.PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3");
 var REFERRAL_ACCOUNT_PUBKEY = new web3_js.PublicKey("Mm7HcujSK2JzPW4eX7g4oqTXbWYDuFxapNMHXe8yp1B");
 var getFeeAccount = (mint) => {
-  const referralProgramPubkey = REFERRAL_PROGRAM_ID;
-  const referralAccountPubkey = REFERRAL_ACCOUNT_PUBKEY;
   const [feeAccount] = web3_js.PublicKey.findProgramAddressSync(
-    [Buffer.from("referral_ata"), referralAccountPubkey.toBuffer(), mint.toBuffer()],
-    referralProgramPubkey
+    [Buffer.from("referral_ata"), REFERRAL_ACCOUNT_PUBKEY.toBuffer(), mint.toBuffer()],
+    REFERRAL_PROGRAM_ID
   );
   return feeAccount.toBase58();
 };
+var checkFeeAccount = async (connection, mint) => {
+  const feeAccount = getFeeAccount(mint);
+  const hasFeeAccount = !!await connection.getAccountInfo(new web3_js.PublicKey(feeAccount));
+  return { feeAccount, hasFeeAccount };
+};
 function deserializeJupiterInstruction(instruction) {
   return new web3_js.TransactionInstruction({
     programId: new web3_js.PublicKey(instruction.programId),
@@ -48907,17 +50292,26 @@ function deserializeJupiterInstruction(instruction) {
     data: Buffer.from(instruction.data, "base64")
   });
 }
+function toJupiterConfig(apiConfig) {
+  if (!apiConfig) return void 0;
+  return {
+    basePath: apiConfig.basePath,
+    apiKey: apiConfig.apiKey ? () => apiConfig.apiKey : void 0,
+    headers: apiConfig.headers
+  };
+}
 var getJupiterSwapIxsForFlashloan = async ({
   quoteParams,
   authority,
   connection,
   destinationTokenAccount,
-  configParams
+  apiConfig,
+  maxSwapAccounts
 }) => {
+  const configParams = toJupiterConfig(apiConfig);
   const jupiterApiClient = configParams?.basePath ? new api.SwapApi(new api.Configuration(configParams)) : api.createJupiterApiClient(configParams);
   const feeMint = quoteParams.swapMode === "ExactIn" ? quoteParams.outputMint : quoteParams.inputMint;
-  const feeAccount = getFeeAccount(new web3_js.PublicKey(feeMint));
-  const hasFeeAccount = !!await connection.getAccountInfo(new web3_js.PublicKey(feeAccount));
+  const { feeAccount, hasFeeAccount } = await checkFeeAccount(connection, new web3_js.PublicKey(feeMint));
   const project0JupiterLut = (await connection.getAddressLookupTable(ADDRESS_LOOKUP_TABLE_FOR_SWAP))?.value;
   let finalQuoteParams = quoteParams;
   if (!hasFeeAccount) {
@@ -48927,67 +50321,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 web3_js.PublicKey(address))
+    lutAddresses.map((address) => new web3_js.PublicKey(address))
   );
-  let currentIndex = 0;
-  const jupiterSwapIxs = [];
-  for (let i = 0; i < swapInstructionResponses.length; i++) {
-    const response = swapInstructionResponses[i];
-    const quote = swapQuotes[i];
-    if (!response || !quote) continue;
-    const address = response.addressLookupTableAddresses;
-    const addressesLength = address.length;
-    const addressesStartIndex = currentIndex;
-    const addressesEndIndex = addressesStartIndex + addressesLength;
-    currentIndex = addressesEndIndex;
-    const lutAccounts = lutAccountsRaw.slice(addressesStartIndex, addressesEndIndex);
-    const addressLookupTableAccounts = lutAccounts.map((accountInfo, index) => {
-      const addressLookupTableAddress = address[index];
-      if (!accountInfo || !addressLookupTableAddress) {
-        return null;
-      }
-      return new web3_js.AddressLookupTableAccount({
-        key: new web3_js.PublicKey(addressLookupTableAddress),
-        state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
-      });
-    }).filter((account) => account !== null).concat(project0JupiterLut ? [project0JupiterLut] : []);
-    const instruction = deserializeJupiterInstruction(response.swapInstruction);
-    const setupInstructions = response.setupInstructions.map(deserializeJupiterInstruction);
-    jupiterSwapIxs.push({
-      swapInstruction: instruction,
-      setupInstructions,
-      addressLookupTableAddresses: addressLookupTableAccounts,
-      quoteResponse: quote
+  const addressLookupTableAccounts = lutAccountsRaw.map((accountInfo, index) => {
+    const addressLookupTableAddress = lutAddresses[index];
+    if (!accountInfo || !addressLookupTableAddress) {
+      return null;
+    }
+    return new web3_js.AddressLookupTableAccount({
+      key: new web3_js.PublicKey(addressLookupTableAddress),
+      state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
     });
-  }
-  return jupiterSwapIxs;
+  }).filter((account) => account !== null).concat(project0JupiterLut ? [project0JupiterLut] : []);
+  const instruction = deserializeJupiterInstruction(swapInstructionResponse.swapInstruction);
+  const setupInstructions = swapInstructionResponse.setupInstructions.map(
+    deserializeJupiterInstruction
+  );
+  return {
+    swapInstructions: [instruction],
+    setupInstructions,
+    addressLookupTableAddresses: addressLookupTableAccounts,
+    quoteResponse: mapJupiterQuoteToSwapQuoteResult(swapQuote)
+  };
 };
 
 // src/services/account/utils/misc.utils.ts
@@ -50208,7 +51579,7 @@ function computeMaxLeverage(depositBank, borrowBank, opts) {
     ltv
   };
 }
-function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank, depositOracleInfo, borrowOracleInfo, opts) {
+function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank, depositPriceUsd, borrowPriceUsd, opts) {
   const initialCollateral = toBigNumber(principal);
   const { maxLeverage } = computeMaxLeverage(depositBank, borrowBank, opts);
   let clampedLeverage = targetLeverage;
@@ -50223,7 +51594,7 @@ function computeLoopingParams(principal, targetLeverage, depositBank, borrowBank
   }
   const totalDepositAmount = initialCollateral.times(new BigNumber3__default.default(clampedLeverage));
   const additionalDepositAmount = totalDepositAmount.minus(initialCollateral);
-  const totalBorrowAmount = additionalDepositAmount.times(depositOracleInfo.priceWeighted.lowestPrice).div(borrowOracleInfo.priceWeighted.highestPrice);
+  const totalBorrowAmount = additionalDepositAmount.times(new BigNumber3__default.default(depositPriceUsd)).div(new BigNumber3__default.default(borrowPriceUsd));
   return {
     totalBorrowAmount: totalBorrowAmount.decimalPlaces(
       borrowBank.mintDecimals,
@@ -52690,7 +54061,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.depositOpts - Deposit configuration (bank, amount, mode)
    * @param params.borrowOpts - Borrow configuration (bank, amount)
-   * @param params.swapOpts - Jupiter swap configuration (slippage, fees)
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52728,7 +54099,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.withdrawOpts - Withdraw configuration (bank, amount)
    * @param params.repayOpts - Repay configuration (bank, optional amount)
-   * @param params.swapOpts - Jupiter swap configuration
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52768,7 +54139,7 @@ var MarginfiAccount = class _MarginfiAccount {
    * @param params.oraclePrices - Map of current oracle prices
    * @param params.withdrawOpts - Withdraw configuration (bank, amount, tokenProgram)
    * @param params.depositOpts - Deposit configuration (bank, tokenProgram)
-   * @param params.swapOpts - Jupiter swap configuration
+   * @param params.swapOpts - Swap configuration (venue, slippage, fees)
    * @param params.addressLookupTableAccounts - Address lookup tables
    * @param params.overrideInferAccounts - Optional account overrides
    * @param params.additionalIxs - Additional instructions to include
@@ -52808,7 +54179,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
@@ -54156,6 +55527,7 @@ exports.MARGINFI_PROGRAM = MARGINFI_PROGRAM;
 exports.MARGINFI_PROGRAM_STAGING = MARGINFI_PROGRAM_STAGING;
 exports.MARGINFI_PROGRAM_STAGING_ALT = MARGINFI_PROGRAM_STAGING_ALT;
 exports.MARGINFI_SPONSORED_SHARD_ID = MARGINFI_SPONSORED_SHARD_ID;
+exports.MAX_ACCOUNT_LOCKS = MAX_ACCOUNT_LOCKS;
 exports.MAX_CONFIDENCE_INTERVAL_RATIO = MAX_CONFIDENCE_INTERVAL_RATIO;
 exports.MAX_TX_SIZE = MAX_TX_SIZE;
 exports.MAX_U64 = MAX_U64;
@@ -54191,6 +55563,7 @@ exports.SYSTEM_PROGRAM_ID = SYSTEM_PROGRAM_ID;
 exports.SYSVAR_CLOCK_ID = SYSVAR_CLOCK_ID;
 exports.SYSVAR_RENT_ID = SYSVAR_RENT_ID;
 exports.SYSVAR_STAKE_HISTORY_ID = SYSVAR_STAKE_HISTORY_ID;
+exports.SwapProvider = SwapProvider;
 exports.TRANSFER_ACCOUNT_AUTHORITY_FLAG = TRANSFER_ACCOUNT_AUTHORITY_FLAG;
 exports.TransactionArenaKeyMap = TransactionArenaKeyMap;
 exports.TransactionBuildingError = TransactionBuildingError;
@@ -54224,6 +55597,7 @@ exports.checkMultipleOraclesCrankability = checkMultipleOraclesCrankability;
 exports.chunkedGetRawMultipleAccountInfoOrdered = chunkedGetRawMultipleAccountInfoOrdered;
 exports.chunkedGetRawMultipleAccountInfoOrderedWithNulls = chunkedGetRawMultipleAccountInfoOrderedWithNulls;
 exports.chunkedGetRawMultipleAccountInfos = chunkedGetRawMultipleAccountInfos;
+exports.compileFlashloanPrecheck = compileFlashloanPrecheck;
 exports.composeRemainingAccounts = composeRemainingAccounts;
 exports.computeAccountValue = computeAccountValue;
 exports.computeActiveEmodePairs = computeActiveEmodePairs;
@@ -54234,6 +55608,8 @@ exports.computeBaseInterestRate = computeBaseInterestRate;
 exports.computeClaimedEmissions = computeClaimedEmissions;
 exports.computeClosePositionTokenAmount = computeClosePositionTokenAmount;
 exports.computeEmodeImpacts = computeEmodeImpacts;
+exports.computeFlashLoanNonSwapBudget = computeFlashLoanNonSwapBudget;
+exports.computeFlashloanSwapConstraints = computeFlashloanSwapConstraints;
 exports.computeFreeCollateralFromBalances = computeFreeCollateralFromBalances;
 exports.computeFreeCollateralFromCache = computeFreeCollateralFromCache;
 exports.computeHealthAccountMetas = computeHealthAccountMetas;
@@ -54262,6 +55638,7 @@ exports.computeTotalOutstandingEmissions = computeTotalOutstandingEmissions;
 exports.computeTvl = computeTvl;
 exports.computeUsdValue = computeUsdValue;
 exports.computeUtilizationRate = computeUtilizationRate;
+exports.computeV0TxSize = computeV0TxSize;
 exports.convertVoteAccCoeffsToBankCoeffs = convertVoteAccCoeffsToBankCoeffs;
 exports.createActiveEmodePairFromPairs = createActiveEmodePairFromPairs;
 exports.createEmptyBalance = createEmptyBalance;
@@ -54337,6 +55714,7 @@ exports.getDriftCTokenMultiplier = getDriftCTokenMultiplier;
 exports.getDriftMetadata = getDriftMetadata;
 exports.getDriftStatesDto = getDriftStatesDto;
 exports.getEmodePairs = getEmodePairs;
+exports.getExactOutEstimate = getExactOutEstimate;
 exports.getHealthCacheStatusDescription = getHealthCacheStatusDescription;
 exports.getHealthSimulationTransactions = getHealthSimulationTransactions;
 exports.getJupLendFTokenMultiplier = getJupLendFTokenMultiplier;
@@ -54355,10 +55733,15 @@ exports.getOracleSourceNameFromKey = getOracleSourceNameFromKey;
 exports.getPrice = getPrice;
 exports.getPriceWithConfidence = getPriceWithConfidence;
 exports.getStakedBankMetadataMap = getStakedBankMetadataMap;
+exports.getSwapIxsForFlashloan = getSwapIxsForFlashloan;
+exports.getTitanExactOutEstimate = getTitanExactOutEstimate;
+exports.getTitanSwapIxsForFlashloan = getTitanSwapIxsForFlashloan;
+exports.getTotalAccountKeys = getTotalAccountKeys;
 exports.getTotalAssetQuantity = getTotalAssetQuantity;
 exports.getTotalLiabilityQuantity = getTotalLiabilityQuantity;
 exports.getTxSize = getTxSize;
 exports.getValidatorVoteAccountByBank = getValidatorVoteAccountByBank;
+exports.getWritableAccountKeys = getWritableAccountKeys;
 exports.groupToDto = groupToDto;
 exports.hasAccountFlag = hasAccountFlag;
 exports.hasEmodeEntryFlag = hasEmodeEntryFlag;
@@ -54427,6 +55810,7 @@ exports.makeWithdrawIx = makeWithdrawIx3;
 exports.makeWithdrawTx = makeWithdrawTx;
 exports.makeWrapSolIxs = makeWrapSolIxs;
 exports.mapBrokenFeedsToOraclePrices = mapBrokenFeedsToOraclePrices;
+exports.mapJupiterQuoteToSwapQuoteResult = mapJupiterQuoteToSwapQuoteResult;
 exports.mapPythBanksToOraclePrices = mapPythBanksToOraclePrices;
 exports.mapSwbBanksToOraclePrices = mapSwbBanksToOraclePrices;
 exports.marginfiAccountToDto = marginfiAccountToDto;
@@ -54463,6 +55847,7 @@ exports.toBankDto = toBankDto;
 exports.toBigNumber = toBigNumber;
 exports.toEmodeSettingsDto = toEmodeSettingsDto;
 exports.toInterestRateConfigDto = toInterestRateConfigDto;
+exports.toJupiterConfig = toJupiterConfig;
 exports.toNumber = toNumber;
 exports.uiToNative = uiToNative;
 exports.uiToNativeBigNumber = uiToNativeBigNumber;