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

package/dist/index.cjs

@@ -131,6 +131,7 @@ var TransactionBuildingErrorCode = /* @__PURE__ */ ((TransactionBuildingErrorCod
   TransactionBuildingErrorCode2["TRANSFER_POSITIONS_INVALID_SELECTION"] = "TRANSFER_POSITIONS_INVALID_SELECTION";
   TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSUPPORTED_BANK"] = "TRANSFER_POSITIONS_UNSUPPORTED_BANK";
   TransactionBuildingErrorCode2["TRANSFER_POSITIONS_UNSPLITTABLE"] = "TRANSFER_POSITIONS_UNSPLITTABLE";
+  TransactionBuildingErrorCode2["BRIDGE_CONFLICT"] = "BRIDGE_CONFLICT";
   return TransactionBuildingErrorCode2;
 })(TransactionBuildingErrorCode || {});
 var TransactionBuildingError = class _TransactionBuildingError extends Error {
@@ -261,6 +262,19 @@ var TransactionBuildingError = class _TransactionBuildingError extends Error {
       { reason, sizeBytes, accountCount }
     );
   }
+  /**
+   * A bridged (double-hop) swap could not route because every bridge-token candidate bank
+   * conflicts with an existing opposite-side position on the account (marginfi forbids holding an
+   * asset and a liability on the same bank).
+   */
+  static bridgeConflict(conflictingBanks, bridgeTokenSide) {
+    const banksList = conflictingBanks.map((c) => c.symbol ?? c.mint).join(", ");
+    return new _TransactionBuildingError(
+      "BRIDGE_CONFLICT" /* BRIDGE_CONFLICT */,
+      `Every bridge-token candidate conflicts with an existing opposite-side position: ${banksList}`,
+      { conflictingBanks, bridgeTokenSide }
+    );
+  }
   /**
    * Generic escape hatch for custom errors
    */
@@ -277,6 +291,9 @@ var DECOMPOSABLE_SWAP_ERROR_CODES = /* @__PURE__ */ new Set([
 function isDecomposableSwapError(e) {
   return e instanceof TransactionBuildingError && DECOMPOSABLE_SWAP_ERROR_CODES.has(e.code);
 }
+function isBridgeConflictError(e) {
+  return e instanceof TransactionBuildingError && e.code === "BRIDGE_CONFLICT" /* BRIDGE_CONFLICT */;
+}
 var PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED = Buffer.from("liquidity_vault_auth");
 var PDA_BANK_INSURANCE_VAULT_AUTH_SEED = Buffer.from("insurance_vault_auth");
 var PDA_BANK_FEE_VAULT_AUTH_SEED = Buffer.from("fee_vault_auth");
@@ -436,6 +453,7 @@ var PRIORITY_TX_SIZE = 44;
 var WSOL_MINT = new web3_js.PublicKey("So11111111111111111111111111111111111111112");
 var LST_MINT = new web3_js.PublicKey("LSTxxxnJzKDFSLr4dUkPcmCf5VyryEqzPLz5j4bpxFp");
 var USDC_MINT = new web3_js.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var USDT_MINT = new web3_js.PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB");
 var USDC_DECIMALS = 6;
 
 // src/utils/accounting.utils.ts
@@ -67237,1775 +67255,298 @@ function annotateFit(route, req) {
   };
 }
 
-// src/services/account/actions/loop.ts
-async function makeLoopTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    bankMap,
-    depositOpts,
-    borrowOpts,
-    bankMetadataMap,
-    addressLookupTableAccounts,
-    connection,
-    oraclePrices,
-    crossbarUrl,
-    additionalIxs = []
-  } = params;
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      {
-        mint: borrowOpts.borrowBank.mint,
-        tokenProgram: borrowOpts.tokenProgram
-      },
-      {
-        mint: depositOpts.depositBank.mint,
-        tokenProgram: depositOpts.tokenProgram
-      }
-    ]
-  });
-  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
-    params.marginfiAccount,
-    params.bankMap,
-    [depositOpts.depositBank.address],
-    params.bankMetadataMap,
-    [borrowOpts.borrowBank.address, depositOpts.depositBank.address]
-  );
-  const { flashloanTx, setupInstructions, swapQuote, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
-    ...params,
-    blockhash
-  });
-  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
-    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
-      return false;
-    }
-    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
-        return false;
-      }
-    }
-    return true;
-  });
-  setupIxs.push(...jupiterSetupInstructions);
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  let additionalTxs = [];
-  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
-    setupIxs.push(
-      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber3.BigNumber(depositOpts.inputDepositAmount))
-    );
+// src/models/balance.ts
+var Balance = class _Balance {
+  constructor(active, bankPk, assetShares, liabilityShares, emissionsOutstanding, lastUpdate) {
+    this.active = active;
+    this.bankPk = bankPk;
+    this.assetShares = assetShares;
+    this.liabilityShares = liabilityShares;
+    this.emissionsOutstanding = emissionsOutstanding;
+    this.lastUpdate = lastUpdate;
   }
-  if (setupIxs.length > 0 || additionalIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
-    const ixs = [...additionalIxs, ...setupIxs, ...refreshIntegrationIxs.instructions];
-    const txs = splitInstructionsToFitTransactions([], ixs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
+  static from(balanceRaw) {
+    const props = parseBalanceRaw(balanceRaw);
+    return new _Balance(
+      props.active,
+      props.bankPk,
+      props.assetShares,
+      props.liabilityShares,
+      props.emissionsOutstanding,
+      props.lastUpdate
     );
   }
-  if (updateFeedIxs.length > 0) {
-    const message = new web3_js.TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
+  static fromBalanceType(balance) {
+    return new _Balance(
+      balance.active,
+      balance.bankPk,
+      balance.assetShares,
+      balance.liabilityShares,
+      balance.emissionsOutstanding,
+      balance.lastUpdate
     );
   }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildLoopFlashloanTx(params) {
-  const { depositOpts } = params;
-  const { descriptor, swapNeeded, borrowIxs, depositIxs } = await buildLoopNonSwapIxs(params);
-  if (!swapNeeded) {
-    const flashloanTx2 = await finalizeLoopFlashloanTx({
-      params,
-      innerIxs: descriptor.innerIxs,
-      luts: descriptor.luts,
-      swapIxCount: 0,
-      swapLutCount: 0,
-      sizeConstraint: descriptor.sizeConstraint
+  static createEmpty(bankPk) {
+    const balance = createEmptyBalance(bankPk);
+    return this.fromBalanceType(balance);
+  }
+  computeUsdValue(bank, oraclePrice, marginRequirement = 2 /* Equity */, assetShareValueMultiplier, activeEmodeWeights) {
+    return computeBalanceUsdValue({
+      balance: this,
+      bank,
+      oraclePrice,
+      marginRequirement,
+      assetShareValueMultiplier,
+      activeEmodeWeights
     });
-    return {
-      flashloanTx: flashloanTx2,
-      setupInstructions: [],
-      swapQuote: void 0,
-      borrowIxs,
-      depositIxs
-    };
   }
-  const engineResult = await runLoopSwapEngine(descriptor, params);
-  const finalIxs = [...descriptor.innerIxs];
-  finalIxs.splice(descriptor.swapSlotIndex, 0, ...engineResult.swapInstructions);
-  const principalNative = depositOpts.loopMode === "DEPOSIT" ? uiToNative(depositOpts.inputDepositAmount, depositOpts.depositBank.mintDecimals) : new BN9__default.default(0);
-  const finalDepositNative = engineResult.outputAmountNative.add(principalNative);
-  const depositIxPosition = descriptor.depositIxIndex + engineResult.swapInstructions.length;
-  patchDepositAmount(finalIxs[depositIxPosition], finalDepositNative);
-  const luts = [...descriptor.luts, ...engineResult.swapLuts];
-  const flashloanTx = await finalizeLoopFlashloanTx({
-    params,
-    innerIxs: finalIxs,
-    luts,
-    swapIxCount: engineResult.swapInstructions.length,
-    swapLutCount: engineResult.swapLuts.length,
-    sizeConstraint: descriptor.sizeConstraint
-  });
-  return {
-    flashloanTx,
-    setupInstructions: engineResult.setupInstructions,
-    swapQuote: engineResult.quoteResponse,
-    borrowIxs,
-    depositIxs
-  };
-}
-async function buildLoopNonSwapIxs(params) {
-  const {
-    program,
-    marginfiAccount,
-    bankMap,
-    borrowOpts,
-    depositOpts,
-    bankMetadataMap,
-    addressLookupTableAccounts,
-    overrideInferAccounts
-  } = params;
-  const cuRequestIxs = [
-    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  const swapNeeded = !depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint);
-  const destinationTokenAccount = getAssociatedTokenAddressSync(
-    new web3_js.PublicKey(depositOpts.depositBank.mint),
-    marginfiAccount.authority,
-    true,
-    depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
-  );
-  const principalUi = depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0;
-  let depositAmountUi;
-  let sizeConstraint = 0;
-  let maxSwapTotalAccounts = 0;
-  if (!swapNeeded) {
-    depositAmountUi = borrowOpts.borrowAmount + principalUi;
-  } else {
-    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
+  getUsdValueWithPriceBias(bank, oraclePrice, marginRequirement = 2 /* Equity */, assetShareValueMultiplier, activeEmodeWeights) {
+    return getBalanceUsdValueWithPriceBias({
+      balance: this,
+      bank,
+      oraclePrice,
+      marginRequirement,
+      assetShareValueMultiplier,
+      activeEmodeWeights
     });
-    sizeConstraint = swapConstraints.sizeConstraint;
-    maxSwapTotalAccounts = swapConstraints.maxSwapTotalAccounts;
-    const estimateUi = borrowOpts.borrowAmount * borrowOpts.marketPrice / depositOpts.marketPrice;
-    depositAmountUi = estimateUi + principalUi;
   }
-  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
-    }
-  });
-  const depositIxs = await buildDepositIxs(params, depositAmountUi);
-  const innerIxsBeforeSwap = [...cuRequestIxs, ...borrowIxs.instructions];
-  const swapSlotIndex = innerIxsBeforeSwap.length;
-  const innerIxs = [...innerIxsBeforeSwap, ...depositIxs.instructions];
-  const depositIxIndex = innerIxs.findIndex(isDepositIx);
-  if (depositIxIndex < 0) {
-    throw new Error(
-      "buildLoopNonSwapIxs: could not locate deposit instruction for amount patching"
-    );
+  computeQuantity(bank) {
+    return computeQuantity(this, bank);
   }
-  const descriptor = {
-    innerIxs,
-    swapSlotIndex,
-    depositIxIndex,
-    inputMint: borrowOpts.borrowBank.mint.toBase58(),
-    outputMint: depositOpts.depositBank.mint.toBase58(),
-    inputDecimals: borrowOpts.borrowBank.mintDecimals,
-    outputDecimals: depositOpts.depositBank.mintDecimals,
-    inAmountNative: uiToNative(
-      borrowOpts.borrowAmount,
-      borrowOpts.borrowBank.mintDecimals
-    ).toNumber(),
-    destinationTokenAccount,
-    sizeConstraint,
-    maxSwapTotalAccounts,
-    luts: addressLookupTableAccounts ?? []
-  };
-  return { descriptor, swapNeeded, borrowIxs, depositIxs };
-}
-async function buildDepositIxs(params, amountUi) {
-  const { program, marginfiAccount, depositOpts, bankMetadataMap, overrideInferAccounts } = params;
-  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
-        );
-      }
-      return makeKaminoDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountUi,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        reserve,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-    }
-    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
-        );
-      }
-      return makeDriftDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountUi,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        driftMarketIndex: driftState.spotMarketState.marketIndex,
-        driftOracle: driftState.spotMarketState.oracle,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-    }
-    case 6 /* JUPLEND */: {
-      return makeJuplendDepositIx2({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountUi,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-    }
-    default: {
-      return makeDepositIx3({
-        program,
-        bank: depositOpts.depositBank,
-        tokenProgram: depositOpts.tokenProgram,
-        amount: amountUi,
-        accountAddress: marginfiAccount.address,
-        authority: marginfiAccount.authority,
-        group: marginfiAccount.group,
-        opts: {
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-    }
+  computeQuantityUi(bank, assetShareValueMultiplier) {
+    return computeQuantityUi(this, bank, assetShareValueMultiplier);
   }
-}
-async function runLoopSwapEngine(descriptor, params) {
-  const { connection, swapOpts, marginfiAccount, swapEngineRunner } = params;
-  if (swapOpts.swapIxs) {
-    return {
-      swapInstructions: swapOpts.swapIxs.instructions,
-      setupInstructions: [],
-      swapLuts: swapOpts.swapIxs.lookupTables,
-      quoteResponse: {
-        inAmount: String(descriptor.inAmountNative),
-        outAmount: "0",
-        otherAmountThreshold: "0",
-        slippageBps: 0
-      },
-      outputAmountNative: new BN9__default.default(0)
-    };
+  computeTotalOutstandingEmissions(bank) {
+    return computeTotalOutstandingEmissions(this, bank);
   }
-  const runEngine = swapEngineRunner ?? runSwapEngine;
-  const engineResult = await runEngine({
-    inputMint: descriptor.inputMint,
-    outputMint: descriptor.outputMint,
-    amountNative: descriptor.inAmountNative,
-    inputDecimals: descriptor.inputDecimals,
-    outputDecimals: descriptor.outputDecimals,
-    ...swapEngineQuoteFieldsFromOpts(swapOpts),
-    taker: marginfiAccount.authority,
-    destinationTokenAccount: descriptor.destinationTokenAccount,
-    connection,
-    footprint: {
-      instructions: descriptor.innerIxs,
-      luts: descriptor.luts,
-      payer: marginfiAccount.authority,
-      sizeConstraint: descriptor.sizeConstraint,
-      maxSwapTotalAccounts: descriptor.maxSwapTotalAccounts
-    },
-    providers: swapEngineProvidersFromOpts(swapOpts)
-  });
-  return {
-    swapInstructions: engineResult.swapInstructions,
-    setupInstructions: engineResult.setupInstructions,
-    swapLuts: engineResult.swapLuts,
-    quoteResponse: engineResult.quoteResponse,
-    outputAmountNative: engineResult.outputAmountNative
-  };
-}
-async function finalizeLoopFlashloanTx({
-  params,
-  innerIxs,
-  luts,
-  swapIxCount,
-  swapLutCount,
-  sizeConstraint
-}) {
-  const { program, marginfiAccount, bankMap, swapOpts, blockhash } = params;
-  if (swapIxCount > 0) {
-    compileFlashloanPrecheck({
-      allIxs: innerIxs,
-      payer: marginfiAccount.authority,
-      luts,
-      sizeConstraint,
-      swapIxCount,
-      swapLutCount
-    });
+  computeClaimedEmissions(bank, currentTimestamp) {
+    return computeClaimedEmissions(this, bank, currentTimestamp);
   }
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: innerIxs
-  });
-  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
+};
+
+// src/models/health-cache.ts
+var HealthCache = class _HealthCache {
+  constructor(assetValue, liabilityValue, assetValueMaint, liabilityValueMaint, assetValueEquity, liabilityValueEquity, timestamp, flags, prices, simulationStatus) {
+    this.assetValue = assetValue;
+    this.liabilityValue = liabilityValue;
+    this.assetValueMaint = assetValueMaint;
+    this.liabilityValueMaint = liabilityValueMaint;
+    this.assetValueEquity = assetValueEquity;
+    this.liabilityValueEquity = liabilityValueEquity;
+    this.timestamp = timestamp;
+    this.flags = flags;
+    this.prices = prices;
+    this.simulationStatus = simulationStatus;
+  }
+  static fromHealthCacheType(healthCacheType) {
+    return new _HealthCache(
+      healthCacheType.assetValue,
+      healthCacheType.liabilityValue,
+      healthCacheType.assetValueMaint,
+      healthCacheType.liabilityValueMaint,
+      healthCacheType.assetValueEquity,
+      healthCacheType.liabilityValueEquity,
+      healthCacheType.timestamp,
+      healthCacheType.flags,
+      healthCacheType.prices,
+      healthCacheType.simulationStatus
     );
   }
-  return flashloanTx;
-}
-async function makeSwapCollateralTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    connection,
-    bankMap,
-    oraclePrices,
-    withdrawOpts,
-    depositOpts,
-    bankMetadataMap,
-    assetShareValueMultiplierByBank,
-    addressLookupTableAccounts,
-    crossbarUrl,
-    additionalIxs = []
-  } = params;
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
-      { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
-    ]
-  });
-  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
-    marginfiAccount,
-    bankMap,
-    [withdrawOpts.withdrawBank.address, depositOpts.depositBank.address],
-    bankMetadataMap
-  );
-  const { flashloanTx, setupInstructions, swapQuote, withdrawIxs, depositIxs } = await buildSwapCollateralFlashloanTx({
-    ...params,
-    blockhash
-  });
-  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
-    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
-      return false;
-    }
-    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(depositOpts.depositBank.mint)) {
-        return false;
-      }
-    }
-    return true;
-  });
-  setupIxs.push(...jupiterSetupInstructions);
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank,
-    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  let additionalTxs = [];
-  if (setupIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
-    const ixs = [...setupIxs, ...refreshIntegrationIxs.instructions];
-    const txs = splitInstructionsToFitTransactions([], ixs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
-    );
+  static from(healthCacheRaw) {
+    return this.fromHealthCacheType(parseHealthCacheRaw(healthCacheRaw));
   }
-  if (updateFeedIxs.length > 0) {
-    const message = new web3_js.TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
-    );
+};
+
+// src/models/account.ts
+var MarginfiAccount = class _MarginfiAccount {
+  constructor(address, group, authority, balances, accountFlags, emissionsDestinationAccount, healthCache) {
+    this.address = address;
+    this.group = group;
+    this.authority = authority;
+    this.balances = balances;
+    this.accountFlags = accountFlags;
+    this.emissionsDestinationAccount = emissionsDestinationAccount;
+    this.healthCache = healthCache;
   }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildSwapCollateralFlashloanTx({
-  program,
-  marginfiAccount,
-  bankMap,
-  withdrawOpts,
-  depositOpts,
-  swapOpts,
-  bankMetadataMap,
-  assetShareValueMultiplierByBank,
-  addressLookupTableAccounts,
-  connection,
-  overrideInferAccounts,
-  blockhash,
-  swapEngineRunner
-}) {
-  const {
-    withdrawBank,
-    tokenProgram: withdrawTokenProgram,
-    totalPositionAmount,
-    withdrawAmount
-  } = withdrawOpts;
-  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
-  if (withdrawAmount !== void 0 && withdrawAmount <= 0) {
-    throw new Error("withdrawAmount must be greater than 0");
+  /**
+   * Fetches a marginfi account from on-chain data.
+   *
+   * @param address - The public key of the marginfi account
+   * @param program - The Marginfi program instance
+   *
+   * @returns Promise resolving to a MarginfiAccount instance
+   */
+  static async fetch(address, program) {
+    const data = await program.account.marginfiAccount.fetch(address);
+    return _MarginfiAccount.fromAccountParsed(address, data);
   }
-  const actualWithdrawAmount = Math.min(withdrawAmount ?? totalPositionAmount, totalPositionAmount);
-  const isFullWithdraw = isWholePosition(
-    { amount: totalPositionAmount, isLending: true },
-    actualWithdrawAmount,
-    withdrawBank.mintDecimals
-  );
-  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 */: {
-      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(actualWithdrawAmount).div(multiplier).times(1.0001).toNumber();
-      withdrawIxs = await makeKaminoWithdrawIx3({
-        program,
-        bank: withdrawBank,
-        bankMap,
-        tokenProgram: withdrawTokenProgram,
-        cTokenAmount: adjustedAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        reserve,
-        withdrawAll: isFullWithdraw,
-        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: actualWithdrawAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        driftSpotMarket: driftState.spotMarketState,
-        userRewards: driftState.userRewards,
-        withdrawAll: isFullWithdraw,
-        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: withdrawBank,
-        bankMap,
-        tokenProgram: withdrawTokenProgram,
-        amount: actualWithdrawAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        jupLendingState: jupLendState.jupLendingState,
-        withdrawAll: isFullWithdraw,
-        opts: {
-          createAtas: false,
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
-    default: {
-      withdrawIxs = await makeWithdrawIx3({
-        program,
-        bank: withdrawBank,
-        bankMap,
-        tokenProgram: withdrawTokenProgram,
-        amount: actualWithdrawAmount,
-        marginfiAccount,
-        authority: marginfiAccount.authority,
-        withdrawAll: isFullWithdraw,
-        isSync: false,
-        opts: {
-          createAtas: false,
-          wrapAndUnwrapSol: false,
-          overrideInferAccounts
-        }
-      });
-      break;
-    }
+  static decodeAccountRaw(encoded, idl) {
+    return decodeAccountRaw(encoded, idl);
   }
-  const swapNeeded = !depositBank.mint.equals(withdrawBank.mint);
-  amountToDeposit = swapNeeded ? 0 : actualWithdrawAmount;
-  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;
-    }
-    case 4 /* DRIFT */: {
-      const driftState = bankMetadataMap[depositBank.address.toBase58()]?.driftStates;
-      if (!driftState) {
-        throw TransactionBuildingError.driftStateNotFound(
-          depositBank.address.toBase58(),
-          depositBank.mint.toBase58(),
-          depositBank.tokenSymbol
-        );
-      }
-      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;
-    }
+  static fromAccountType(account) {
+    return new _MarginfiAccount(
+      account.address,
+      account.group,
+      account.authority,
+      account.balances.map((b) => Balance.fromBalanceType(b)),
+      account.accountFlags,
+      account.emissionsDestinationAccount,
+      account.healthCache
+    );
   }
-  if (swapNeeded) {
-    const destinationTokenAccount = getAssociatedTokenAddressSync(
-      depositBank.mint,
-      marginfiAccount.authority,
-      true,
-      depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+  /**
+   * Creates a MarginfiAccount instance from parsed account data.
+   *
+   * @param marginfiAccountPk - The public key of the marginfi account
+   * @param accountData - The raw account data from the program
+   *
+   * @returns A new MarginfiAccount instance
+   */
+  static fromAccountParsed(marginfiAccountPk, accountData) {
+    const props = parseMarginfiAccountRaw(marginfiAccountPk, accountData);
+    return new _MarginfiAccount(
+      props.address,
+      props.group,
+      props.authority,
+      props.balances.map((b) => Balance.fromBalanceType(b)),
+      props.accountFlags,
+      props.emissionsDestinationAccount,
+      HealthCache.fromHealthCacheType(props.healthCache)
     );
-    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
-    });
-    sizeConstraintUsed = swapConstraints.sizeConstraint;
-    const runEngine = swapEngineRunner ?? runSwapEngine;
-    const engineResult = await runEngine({
-      inputMint: withdrawBank.mint.toBase58(),
-      outputMint: depositBank.mint.toBase58(),
-      amountNative: uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toNumber(),
-      inputDecimals: withdrawBank.mintDecimals,
-      outputDecimals: depositBank.mintDecimals,
-      ...swapEngineQuoteFieldsFromOpts(swapOpts),
-      taker: marginfiAccount.authority,
-      destinationTokenAccount,
-      connection,
-      footprint: {
-        instructions: [...cuRequestIxs, ...withdrawIxs.instructions, ...depositIxs.instructions],
-        luts: addressLookupTableAccounts ?? [],
-        payer: marginfiAccount.authority,
-        sizeConstraint: swapConstraints.sizeConstraint,
-        maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
-      },
-      providers: swapEngineProvidersFromOpts(swapOpts)
-    });
-    const depositIxToPatch = depositIxs.instructions.find(isDepositIx);
-    if (!depositIxToPatch) {
-      throw new Error("swap-collateral: could not locate deposit instruction for amount patching");
-    }
-    patchDepositAmount(depositIxToPatch, engineResult.outputAmountNative);
-    swapInstructions = engineResult.swapInstructions;
-    setupInstructions = engineResult.setupInstructions;
-    swapLookupTables = engineResult.swapLuts;
-    swapQuote = engineResult.quoteResponse;
   }
-  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
+  /**
+   * Simulates and updates the health cache for this account.
+   *
+   * Fetches current oracle prices and computes fresh health values. Returns a new
+   * account instance with updated health cache (does not mutate this instance).
+   *
+   * @param params - Configuration for health cache simulation (excluding marginfiAccount)
+   * @returns Object containing the updated account and any errors
+   */
+  async simulateHealthCache(params) {
+    const accountWithHealthCache = await simulateAccountHealthCacheWithFallback({
+      marginfiAccount: this,
+      ...params
     });
+    return {
+      account: _MarginfiAccount.fromAccountType(accountWithHealthCache.marginfiAccount),
+      error: accountWithHealthCache.error
+    };
   }
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: allNonFlIxs,
-    isSync: false
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededPositionSwap(
-      txSize,
-      totalKeys,
-      swapOpts.swapConfig?.provider
-    );
+  static fromAccountDataRaw(marginfiAccountPk, rawData, idl) {
+    const marginfiAccountData = _MarginfiAccount.decodeAccountRaw(rawData, idl);
+    return _MarginfiAccount.fromAccountParsed(marginfiAccountPk, marginfiAccountData);
   }
-  return {
-    flashloanTx,
-    setupInstructions,
-    swapQuote,
-    withdrawIxs,
-    depositIxs
-  };
-}
-async function makeSwapDebtTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    connection,
-    bankMap,
-    oraclePrices,
-    repayOpts,
-    borrowOpts,
-    bankMetadataMap,
-    assetShareValueMultiplierByBank,
-    addressLookupTableAccounts,
-    crossbarUrl,
-    additionalIxs = []
-  } = params;
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      { mint: repayOpts.repayBank.mint, tokenProgram: repayOpts.tokenProgram },
-      { mint: borrowOpts.borrowBank.mint, tokenProgram: borrowOpts.tokenProgram }
-    ]
-  });
-  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
-    marginfiAccount,
-    bankMap,
-    [],
-    bankMetadataMap,
-    [repayOpts.repayBank.address, borrowOpts.borrowBank.address]
-  );
-  const { flashloanTx, setupInstructions, swapQuote, borrowIxs, repayIxs } = await buildSwapDebtFlashloanTx({
-    ...params,
-    blockhash
-  });
-  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
-    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
-      return false;
-    }
-    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mintKey = ix.keys[3]?.pubkey;
-      if (mintKey?.equals(repayOpts.repayBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
-        return false;
-      }
-    }
-    return true;
-  });
-  setupIxs.push(...jupiterSetupInstructions);
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank,
-    instructions: [...borrowIxs.instructions, ...repayIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  let additionalTxs = [];
-  if (setupIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
-    const ixs = [...additionalIxs, ...setupIxs, ...refreshIntegrationIxs.instructions];
-    const txs = splitInstructionsToFitTransactions([], ixs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
-    );
+  // ----------------------------------------------------------------------------
+  // Attributes
+  // ----------------------------------------------------------------------------
+  /**
+   * Gets all balances that are currently active (non-zero).
+   *
+   * @returns Array of active Balance instances
+   */
+  get activeBalances() {
+    return this.balances.filter((b) => b.active);
   }
-  if (updateFeedIxs.length > 0) {
-    const message = new web3_js.TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
-    );
+  /**
+   * Gets the balance for a specific bank.
+   *
+   * @param bankPk - The public key of the bank
+   *
+   * @returns The Balance instance for the bank (may be empty)
+   */
+  getBalance(bankPk) {
+    return Balance.fromBalanceType(getBalance(bankPk, this.balances));
   }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildSwapDebtFlashloanTx({
-  program,
-  marginfiAccount,
-  bankMap,
-  repayOpts,
-  borrowOpts,
-  swapOpts,
-  bankMetadataMap,
-  addressLookupTableAccounts,
-  connection,
-  overrideInferAccounts,
-  blockhash,
-  swapEngineRunner
-}) {
-  const {
-    repayBank,
-    tokenProgram: repayTokenProgram,
-    totalPositionAmount,
-    repayAmount
-  } = repayOpts;
-  const { borrowBank, tokenProgram: borrowTokenProgram } = borrowOpts;
-  if (repayAmount !== void 0 && repayAmount <= 0) {
-    throw new Error("repayAmount must be greater than 0");
+  /**
+   * Checks if the account is disabled.
+   *
+   * @returns True if the account is disabled, false otherwise
+   */
+  get isDisabled() {
+    return this.accountFlags.includes(1 /* ACCOUNT_DISABLED */);
   }
-  const actualRepayAmount = Math.min(repayAmount ?? totalPositionAmount, totalPositionAmount);
-  const cuRequestIxs = [
-    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  const destinationTokenAccount = getAssociatedTokenAddressSync(
-    repayBank.mint,
-    marginfiAccount.authority,
-    true,
-    repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
-  );
-  const estimatedBorrowAmount = computeBorrowEstimateForRepay({
-    repayTargetUi: actualRepayAmount,
-    repayMarketPrice: repayOpts.marketPrice,
-    borrowMarketPrice: borrowOpts.marketPrice,
-    slippageBps: swapOpts.swapConfig?.slippageBps,
-    isRepayAll: actualRepayAmount >= totalPositionAmount
-  });
-  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 footprintBorrowIxs = await makeBorrowIx3({
-    program,
-    bank: borrowBank,
-    bankMap,
-    tokenProgram: borrowTokenProgram,
-    amount: estimatedBorrowAmount,
-    marginfiAccount,
-    authority: marginfiAccount.authority,
-    isSync: true,
-    opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
-  });
-  const footprintRepayIxs = await makeRepayIx3({
-    program,
-    bank: repayBank,
-    tokenProgram: repayTokenProgram,
-    amount: actualRepayAmount,
-    accountAddress: marginfiAccount.address,
-    authority: marginfiAccount.authority,
-    isSync: true,
-    opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
-  });
-  const runEngine = swapEngineRunner ?? runSwapEngine;
-  const engineResult = await runEngine({
-    inputMint: borrowBank.mint.toBase58(),
-    outputMint: repayBank.mint.toBase58(),
-    amountNative: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
-    inputDecimals: borrowBank.mintDecimals,
-    outputDecimals: repayBank.mintDecimals,
-    ...swapEngineQuoteFieldsFromOpts(swapOpts),
-    taker: marginfiAccount.authority,
-    destinationTokenAccount,
-    connection,
-    footprint: {
-      instructions: [
-        ...cuRequestIxs,
-        ...footprintBorrowIxs.instructions,
-        ...footprintRepayIxs.instructions
-      ],
-      luts: addressLookupTableAccounts ?? [],
-      payer: marginfiAccount.authority,
-      sizeConstraint: swapConstraints.sizeConstraint,
-      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
-    },
-    providers: swapEngineProvidersFromOpts(swapOpts)
-  });
-  const quoteResponse = engineResult.quoteResponse;
-  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
-    }
-  });
-  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 ?? [], ...engineResult.swapLuts];
-  const allNonFlIxs = [
-    ...cuRequestIxs,
-    ...borrowIxs.instructions,
-    ...engineResult.swapInstructions,
-    ...repayIxs.instructions
-  ];
-  compileFlashloanPrecheck({
-    allIxs: allNonFlIxs,
-    payer: marginfiAccount.authority,
-    luts,
-    sizeConstraint: swapConstraints.sizeConstraint,
-    swapIxCount: engineResult.swapInstructions.length,
-    swapLutCount: engineResult.swapLuts.length
-  });
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: allNonFlIxs,
-    isSync: true
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededPositionSwap(
-      txSize,
-      totalKeys,
-      swapOpts.swapConfig?.provider
-    );
+  /**
+   * Checks if the account is currently in a flash loan.
+   *
+   * @returns True if a flash loan is active, false otherwise
+   */
+  get isFlashLoanEnabled() {
+    return this.accountFlags.includes(2 /* ACCOUNT_IN_FLASHLOAN */);
   }
-  return {
-    flashloanTx,
-    setupInstructions: engineResult.setupInstructions,
-    swapQuote: quoteResponse,
-    borrowIxs,
-    repayIxs
-  };
-}
-var DEFAULT_ROLL_SLIPPAGE_BPS = 50;
-var TRADE_PT_EVENT_AMOUNT_OUT_OFFSET = 138;
-var MERGE_EVENT_AMOUNT_SY_OUT_OFFSET = 296;
-async function makeRollPtTx(params) {
-  const {
-    program,
-    marginfiAccount,
-    connection,
-    bankMap,
-    oraclePrices,
-    withdrawOpts,
-    depositOpts,
-    rollOpts,
-    assetShareValueMultiplierByBank,
-    addressLookupTableAccounts,
-    crossbarUrl
-  } = params;
-  if (!rollOpts.maturedMarket && !rollOpts.maturedVault) {
-    throw new Error("roll-pt: rollOpts.maturedMarket or maturedVault is required");
+  /**
+   * Checks if account authority transfer is enabled.
+   *
+   * @returns True if authority transfer is allowed, false otherwise
+   */
+  get isTransferAccountAuthorityEnabled() {
+    return this.accountFlags.includes(8 /* ACCOUNT_TRANSFER_AUTHORITY_ALLOWED */);
   }
-  const merge = await resolveExponentMergeContext({
-    connection,
-    owner: marginfiAccount.authority,
-    market: rollOpts.maturedMarket,
-    vault: rollOpts.maturedVault,
-    ptYtTokenProgram: withdrawOpts.tokenProgram,
-    syTokenProgram: rollOpts.syTokenProgram
-  });
-  const clmm = await resolveExponentClmmTradePtContext({
-    connection,
-    owner: marginfiAccount.authority,
-    market: rollOpts.successorMarket,
-    ptTokenProgram: depositOpts.tokenProgram,
-    syTokenProgram: rollOpts.syTokenProgram
-  });
-  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
-  const setupIxs = await makeSetupIx({
-    connection,
-    authority: marginfiAccount.authority,
-    tokens: [
-      { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
-      { mint: merge.mergeAccounts.mintYt, tokenProgram: withdrawOpts.tokenProgram },
-      { mint: merge.underlying.mint, tokenProgram: merge.underlying.tokenProgram },
-      { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
-    ]
-  });
-  const { flashloanTx, swapQuote, withdrawIxs, depositIxs } = await buildRollPtFlashloanTx({
-    params,
-    merge,
-    clmm,
-    setupIxs,
-    blockhash
-  });
-  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount,
-    bankMap,
-    oraclePrices,
-    assetShareValueMultiplierByBank,
-    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
-    program,
-    connection,
-    crossbarUrl
-  });
-  const additionalTxs = [];
-  if (setupIxs.length > 0) {
-    const txs = splitInstructionsToFitTransactions([], setupIxs, {
-      blockhash,
-      payerKey: marginfiAccount.authority,
-      luts: addressLookupTableAccounts ?? []
-    });
-    additionalTxs.push(
-      ...txs.map(
-        (tx) => addTransactionMetadata(tx, {
-          type: "CREATE_ATA" /* CREATE_ATA */,
-          addressLookupTables: addressLookupTableAccounts
-        })
-      )
-    );
+  /**
+   * Sets the health cache for this account.
+   *
+   * Note: This mutates the account instance. Consider using simulateHealthCache()
+   * for a pure functional approach that returns a new account instance.
+   *
+   * @param value - The new health cache to set
+   */
+  setHealthCache(value) {
+    this.healthCache = value;
   }
-  if (updateFeedIxs.length > 0) {
-    const message = new web3_js.TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
-        addressLookupTables: feedLuts,
-        type: "CRANK" /* CRANK */
-      })
-    );
+  /**
+   * Computes free collateral using cached health values.
+   *
+   * Free collateral represents the amount of collateral that is not backing any liabilities.
+   *
+   * @param opts - Optional configuration
+   * @param opts.clamped - If true, clamps negative values to zero
+   *
+   * @returns The free collateral amount in USD
+   */
+  computeFreeCollateralFromCache(opts) {
+    return computeFreeCollateralFromCache(this, opts);
   }
-  const transactions = [...additionalTxs, flashloanTx];
-  return {
-    transactions,
-    actionTxIndex: transactions.length - 1,
-    quoteResponse: swapQuote
-  };
-}
-async function buildRollPtFlashloanTx({
-  params,
-  merge,
-  clmm,
-  setupIxs,
-  blockhash
-}) {
-  const {
-    program,
-    marginfiAccount,
-    bankMap,
-    withdrawOpts,
-    depositOpts,
-    bankMetadataMap,
-    connection,
-    addressLookupTableAccounts,
-    overrideInferAccounts,
-    rollOpts
-  } = params;
-  const { withdrawBank, tokenProgram: withdrawTokenProgram, totalPositionAmount, withdrawAmount } = withdrawOpts;
-  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
-  const authority = marginfiAccount.authority;
-  if (withdrawAmount !== void 0 && withdrawAmount <= 0) {
-    throw new Error("withdrawAmount must be greater than 0");
+  /**
+   * Computes free collateral from balances using Initial margin requirements.
+   *
+   * Free collateral represents the amount of value available for new borrows or withdrawals.
+   * By default, negative values are clamped to zero.
+   *
+   * @param params - Configuration for free collateral computation (excluding activeBalances)
+   * @returns Free collateral value in USD (clamped to zero by default)
+   */
+  computeFreeCollateralFromBalances(params) {
+    return computeFreeCollateralFromBalances({
+      activeBalances: this.activeBalances,
+      ...params
+    });
   }
-  const actualWithdrawAmount = Math.min(withdrawAmount ?? totalPositionAmount, totalPositionAmount);
-  const isFullWithdraw = isWholePosition(
-    { amount: totalPositionAmount, isLending: true },
-    actualWithdrawAmount,
-    withdrawBank.mintDecimals
-  );
-  const withdrawNative = BigInt(
-    uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toString()
-  );
-  const cuRequestIxs = [
-    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  const withdrawIxs = await makeWithdrawIx3({
-    program,
-    bank: withdrawBank,
-    bankMap,
-    tokenProgram: withdrawTokenProgram,
-    amount: actualWithdrawAmount,
-    marginfiAccount,
-    authority,
-    withdrawAll: isFullWithdraw,
-    isSync: false,
-    opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
-  });
-  const mergeIx = makeExponentMergeIx(merge.mergeAccounts, withdrawNative);
-  const depositIxs = await makeDepositIx3({
-    program,
-    bank: depositBank,
-    tokenProgram: depositTokenProgram,
-    amount: 0,
-    accountAddress: marginfiAccount.address,
-    authority,
-    group: marginfiAccount.group,
-    opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
-  });
-  let luts;
-  if (rollOpts.lookupTable) {
-    const fetched = (await connection.getAddressLookupTable(rollOpts.lookupTable)).value;
-    if (!fetched) {
-      throw new Error(`roll-pt: PT-roll lookup table not found: ${rollOpts.lookupTable.toBase58()}`);
-    }
-    luts = [fetched, merge.addressLookupTable, clmm.addressLookupTable];
-  } else {
-    luts = [
-      ...addressLookupTableAccounts ?? [],
-      merge.addressLookupTable,
-      clmm.addressLookupTable
-    ];
+  /**
+   * Computes health components using cached health values.
+   *
+   * Returns weighted asset and liability values based on the margin requirement type.
+   *
+   * @param marginReqType - The margin requirement type (Initial, Maintenance, or Equity)
+   *
+   * @returns Object containing assets and liabilities values in USD
+   */
+  computeHealthComponentsFromCache(marginRequirement) {
+    return computeHealthComponentsFromCache(this, marginRequirement);
   }
-  const redeemIxs = [...setupIxs, ...cuRequestIxs, ...withdrawIxs.instructions, mergeIx];
-  const mergeReturn = await simulateRollReturn({
-    program,
-    marginfiAccount,
-    bankMap,
-    connection,
-    blockhash,
-    luts,
-    ixs: redeemIxs,
-    programId: EXPONENT_CORE_PROGRAM_ID,
-    label: "merge"
-  });
-  const syExact = readReturnU64(mergeReturn, MERGE_EVENT_AMOUNT_SY_OUT_OFFSET, "merge amount_sy_out");
-  if (syExact <= 0n) {
-    throw new Error("roll-pt: merge would redeem 0 SY (empty/invalid matured vault state)");
-  }
-  const exactPtOut = await quoteClmmTradeOut({
-    connection,
-    clmm,
-    amountInSyNative: syExact,
-    payer: authority
-  });
-  const slippageBps = rollOpts.slippageBps ?? DEFAULT_ROLL_SLIPPAGE_BPS;
-  const minPtOut = exactPtOut * BigInt(1e4 - slippageBps) / 10000n;
-  if (minPtOut <= 0n) {
-    throw new Error("roll-pt: quoted PT out is 0 (insufficient CLMM liquidity for this size)");
-  }
-  const tradeIx = makeExponentClmmTradePtIx(
-    clmm.tradePtAccounts,
-    exponentClmmBuyPtArgs({ amountInSyNative: syExact, minPtOutNative: minPtOut })
-  );
-  const depositIxToPatch = depositIxs.instructions.find(isDepositIx);
-  if (!depositIxToPatch) {
-    throw new Error("roll-pt: could not locate deposit instruction for amount patching");
-  }
-  patchDepositAmount(depositIxToPatch, new BN9__default.default(minPtOut.toString()));
-  const allNonFlIxs = [
-    ...cuRequestIxs,
-    ...withdrawIxs.instructions,
-    mergeIx,
-    tradeIx,
-    ...depositIxs.instructions
-  ];
-  const { sizeConstraint } = computeFlashLoanNonSwapBudget({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    ixs: allNonFlIxs
-  });
-  compileFlashloanPrecheck({
-    allIxs: allNonFlIxs,
-    payer: authority,
-    luts,
-    sizeConstraint,
-    swapIxCount: 0,
-    swapLutCount: 0
-  });
-  const flashloanTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs: allNonFlIxs,
-    isSync: false
-  });
-  const txSize = getTxSize(flashloanTx);
-  const totalKeys = getTotalAccountKeys(flashloanTx);
-  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
-    throw TransactionBuildingError.swapSizeExceededPositionSwap(txSize, totalKeys, void 0);
-  }
-  const swapQuote = {
-    inAmount: syExact.toString(),
-    outAmount: exactPtOut.toString(),
-    otherAmountThreshold: minPtOut.toString(),
-    slippageBps
-  };
-  return { flashloanTx, swapQuote, withdrawIxs, depositIxs };
-}
-async function simulateRollReturn({
-  program,
-  marginfiAccount,
-  bankMap,
-  connection,
-  blockhash,
-  luts,
-  ixs,
-  programId,
-  label
-}) {
-  const quoteTx = await makeFlashLoanTx({
-    program,
-    marginfiAccount,
-    bankMap,
-    addressLookupTableAccounts: luts,
-    blockhash,
-    ixs,
-    isSync: false
-  });
-  const sim = await connection.simulateTransaction(quoteTx, {
-    sigVerify: false,
-    replaceRecentBlockhash: true
-  });
-  const logs = sim.value.logs ?? [];
-  if (process.env.ROLL_DEBUG) {
-    console.error(
-      `[roll ${label} sim] err:`,
-      JSON.stringify(sim.value.err),
-      "returnData:",
-      JSON.stringify(sim.value.returnData),
-      "logsLen:",
-      logs.length,
-      "truncated:",
-      logs.some((l) => l.includes("truncated"))
-    );
-  }
-  const prefix = `Program return: ${programId.toBase58()} `;
-  const line = [...logs].reverse().find((l) => l.startsWith(prefix));
-  if (!line) {
-    throw new Error(
-      `roll-pt: could not read ${label} return data from quote simulation (err=${JSON.stringify(
-        sim.value.err
-      )})`
-    );
-  }
-  return Buffer.from(line.slice(prefix.length), "base64");
-}
-function readReturnU64(data, offset, what) {
-  if (data.length < offset + 8) {
-    throw new Error(`roll-pt: ${what} return data too short (${data.length} bytes)`);
-  }
-  return data.readBigUInt64LE(offset);
-}
-async function quoteClmmTradeOut({
-  connection,
-  clmm,
-  amountInSyNative,
-  payer
-}) {
-  const excluded = /* @__PURE__ */ new Set([
-    clmm.tradePtAccounts.tokenSyEscrow.toBase58(),
-    clmm.tradePtAccounts.tokenFeeTreasurySy.toBase58()
-  ]);
-  const largest = await connection.getTokenLargestAccounts(clmm.sy.mint);
-  const funded = largest.value.find(
-    (a) => !excluded.has(a.address.toBase58()) && BigInt(a.amount) >= amountInSyNative
-  );
-  if (!funded) {
-    throw new Error(
-      "roll-pt: no SY holder large enough to quote the buy \u2014 the roll size exceeds available CLMM liquidity for this pair"
-    );
-  }
-  const parsed = await connection.getParsedAccountInfo(funded.address);
-  const info = parsed.value?.data?.parsed?.info;
-  if (!info?.owner) throw new Error("roll-pt: could not resolve the quote SY holder's owner");
-  const trader = new web3_js.PublicKey(info.owner);
-  const ptTokenProgram = clmm.pt.tokenProgram ?? TOKEN_PROGRAM_ID;
-  const tokenPtTrader = getAssociatedTokenAddressSync(clmm.pt.mint, trader, true, ptTokenProgram);
-  const quoteIx = makeExponentClmmTradePtIx(
-    { ...clmm.tradePtAccounts, trader, tokenSyTrader: funded.address, tokenPtTrader },
-    exponentClmmBuyPtArgs({ amountInSyNative, minPtOutNative: 1n })
-  );
-  const createPtAta = createAssociatedTokenAccountIdempotentInstruction(
-    payer,
-    tokenPtTrader,
-    trader,
-    clmm.pt.mint,
-    ptTokenProgram
-  );
-  const { blockhash } = await connection.getLatestBlockhash("confirmed");
-  const message = new web3_js.TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: blockhash,
-    instructions: [createPtAta, quoteIx]
-  }).compileToV0Message([clmm.addressLookupTable]);
-  const sim = await connection.simulateTransaction(new web3_js.VersionedTransaction(message), {
-    sigVerify: false,
-    replaceRecentBlockhash: true
-  });
-  const rd = sim.value.returnData;
-  if (process.env.ROLL_DEBUG) {
-    console.error("[roll trade quote] err:", JSON.stringify(sim.value.err), "returnData?", !!rd);
-  }
-  if (!rd?.data || rd.programId !== EXPONENT_CLMM_PROGRAM_ID.toBase58()) {
-    throw new Error(
-      `roll-pt: CLMM trade quote produced no return data (err=${JSON.stringify(sim.value.err)})`
-    );
-  }
-  const data = Buffer.from(rd.data[0], rd.data[1]);
-  return readReturnU64(data, TRADE_PT_EVENT_AMOUNT_OUT_OFFSET, "trade_pt amount_out");
-}
-
-// src/models/balance.ts
-var Balance = class _Balance {
-  constructor(active, bankPk, assetShares, liabilityShares, emissionsOutstanding, lastUpdate) {
-    this.active = active;
-    this.bankPk = bankPk;
-    this.assetShares = assetShares;
-    this.liabilityShares = liabilityShares;
-    this.emissionsOutstanding = emissionsOutstanding;
-    this.lastUpdate = lastUpdate;
-  }
-  static from(balanceRaw) {
-    const props = parseBalanceRaw(balanceRaw);
-    return new _Balance(
-      props.active,
-      props.bankPk,
-      props.assetShares,
-      props.liabilityShares,
-      props.emissionsOutstanding,
-      props.lastUpdate
-    );
-  }
-  static fromBalanceType(balance) {
-    return new _Balance(
-      balance.active,
-      balance.bankPk,
-      balance.assetShares,
-      balance.liabilityShares,
-      balance.emissionsOutstanding,
-      balance.lastUpdate
-    );
-  }
-  static createEmpty(bankPk) {
-    const balance = createEmptyBalance(bankPk);
-    return this.fromBalanceType(balance);
-  }
-  computeUsdValue(bank, oraclePrice, marginRequirement = 2 /* Equity */, assetShareValueMultiplier, activeEmodeWeights) {
-    return computeBalanceUsdValue({
-      balance: this,
-      bank,
-      oraclePrice,
-      marginRequirement,
-      assetShareValueMultiplier,
-      activeEmodeWeights
-    });
-  }
-  getUsdValueWithPriceBias(bank, oraclePrice, marginRequirement = 2 /* Equity */, assetShareValueMultiplier, activeEmodeWeights) {
-    return getBalanceUsdValueWithPriceBias({
-      balance: this,
-      bank,
-      oraclePrice,
-      marginRequirement,
-      assetShareValueMultiplier,
-      activeEmodeWeights
-    });
-  }
-  computeQuantity(bank) {
-    return computeQuantity(this, bank);
-  }
-  computeQuantityUi(bank, assetShareValueMultiplier) {
-    return computeQuantityUi(this, bank, assetShareValueMultiplier);
-  }
-  computeTotalOutstandingEmissions(bank) {
-    return computeTotalOutstandingEmissions(this, bank);
-  }
-  computeClaimedEmissions(bank, currentTimestamp) {
-    return computeClaimedEmissions(this, bank, currentTimestamp);
-  }
-};
-
-// src/models/health-cache.ts
-var HealthCache = class _HealthCache {
-  constructor(assetValue, liabilityValue, assetValueMaint, liabilityValueMaint, assetValueEquity, liabilityValueEquity, timestamp, flags, prices, simulationStatus) {
-    this.assetValue = assetValue;
-    this.liabilityValue = liabilityValue;
-    this.assetValueMaint = assetValueMaint;
-    this.liabilityValueMaint = liabilityValueMaint;
-    this.assetValueEquity = assetValueEquity;
-    this.liabilityValueEquity = liabilityValueEquity;
-    this.timestamp = timestamp;
-    this.flags = flags;
-    this.prices = prices;
-    this.simulationStatus = simulationStatus;
-  }
-  static fromHealthCacheType(healthCacheType) {
-    return new _HealthCache(
-      healthCacheType.assetValue,
-      healthCacheType.liabilityValue,
-      healthCacheType.assetValueMaint,
-      healthCacheType.liabilityValueMaint,
-      healthCacheType.assetValueEquity,
-      healthCacheType.liabilityValueEquity,
-      healthCacheType.timestamp,
-      healthCacheType.flags,
-      healthCacheType.prices,
-      healthCacheType.simulationStatus
-    );
-  }
-  static from(healthCacheRaw) {
-    return this.fromHealthCacheType(parseHealthCacheRaw(healthCacheRaw));
-  }
-};
-
-// src/models/account.ts
-var MarginfiAccount = class _MarginfiAccount {
-  constructor(address, group, authority, balances, accountFlags, emissionsDestinationAccount, healthCache) {
-    this.address = address;
-    this.group = group;
-    this.authority = authority;
-    this.balances = balances;
-    this.accountFlags = accountFlags;
-    this.emissionsDestinationAccount = emissionsDestinationAccount;
-    this.healthCache = healthCache;
-  }
-  /**
-   * Fetches a marginfi account from on-chain data.
-   *
-   * @param address - The public key of the marginfi account
-   * @param program - The Marginfi program instance
-   *
-   * @returns Promise resolving to a MarginfiAccount instance
-   */
-  static async fetch(address, program) {
-    const data = await program.account.marginfiAccount.fetch(address);
-    return _MarginfiAccount.fromAccountParsed(address, data);
-  }
-  static decodeAccountRaw(encoded, idl) {
-    return decodeAccountRaw(encoded, idl);
-  }
-  static fromAccountType(account) {
-    return new _MarginfiAccount(
-      account.address,
-      account.group,
-      account.authority,
-      account.balances.map((b) => Balance.fromBalanceType(b)),
-      account.accountFlags,
-      account.emissionsDestinationAccount,
-      account.healthCache
-    );
-  }
-  /**
-   * Creates a MarginfiAccount instance from parsed account data.
-   *
-   * @param marginfiAccountPk - The public key of the marginfi account
-   * @param accountData - The raw account data from the program
-   *
-   * @returns A new MarginfiAccount instance
-   */
-  static fromAccountParsed(marginfiAccountPk, accountData) {
-    const props = parseMarginfiAccountRaw(marginfiAccountPk, accountData);
-    return new _MarginfiAccount(
-      props.address,
-      props.group,
-      props.authority,
-      props.balances.map((b) => Balance.fromBalanceType(b)),
-      props.accountFlags,
-      props.emissionsDestinationAccount,
-      HealthCache.fromHealthCacheType(props.healthCache)
-    );
-  }
-  /**
-   * Simulates and updates the health cache for this account.
-   *
-   * Fetches current oracle prices and computes fresh health values. Returns a new
-   * account instance with updated health cache (does not mutate this instance).
-   *
-   * @param params - Configuration for health cache simulation (excluding marginfiAccount)
-   * @returns Object containing the updated account and any errors
-   */
-  async simulateHealthCache(params) {
-    const accountWithHealthCache = await simulateAccountHealthCacheWithFallback({
-      marginfiAccount: this,
-      ...params
-    });
-    return {
-      account: _MarginfiAccount.fromAccountType(accountWithHealthCache.marginfiAccount),
-      error: accountWithHealthCache.error
-    };
-  }
-  static fromAccountDataRaw(marginfiAccountPk, rawData, idl) {
-    const marginfiAccountData = _MarginfiAccount.decodeAccountRaw(rawData, idl);
-    return _MarginfiAccount.fromAccountParsed(marginfiAccountPk, marginfiAccountData);
-  }
-  // ----------------------------------------------------------------------------
-  // Attributes
-  // ----------------------------------------------------------------------------
-  /**
-   * Gets all balances that are currently active (non-zero).
-   *
-   * @returns Array of active Balance instances
-   */
-  get activeBalances() {
-    return this.balances.filter((b) => b.active);
-  }
-  /**
-   * Gets the balance for a specific bank.
-   *
-   * @param bankPk - The public key of the bank
-   *
-   * @returns The Balance instance for the bank (may be empty)
-   */
-  getBalance(bankPk) {
-    return Balance.fromBalanceType(getBalance(bankPk, this.balances));
-  }
-  /**
-   * Checks if the account is disabled.
-   *
-   * @returns True if the account is disabled, false otherwise
-   */
-  get isDisabled() {
-    return this.accountFlags.includes(1 /* ACCOUNT_DISABLED */);
-  }
-  /**
-   * Checks if the account is currently in a flash loan.
-   *
-   * @returns True if a flash loan is active, false otherwise
-   */
-  get isFlashLoanEnabled() {
-    return this.accountFlags.includes(2 /* ACCOUNT_IN_FLASHLOAN */);
-  }
-  /**
-   * Checks if account authority transfer is enabled.
-   *
-   * @returns True if authority transfer is allowed, false otherwise
-   */
-  get isTransferAccountAuthorityEnabled() {
-    return this.accountFlags.includes(8 /* ACCOUNT_TRANSFER_AUTHORITY_ALLOWED */);
-  }
-  /**
-   * Sets the health cache for this account.
-   *
-   * Note: This mutates the account instance. Consider using simulateHealthCache()
-   * for a pure functional approach that returns a new account instance.
-   *
-   * @param value - The new health cache to set
-   */
-  setHealthCache(value) {
-    this.healthCache = value;
-  }
-  /**
-   * Computes free collateral using cached health values.
-   *
-   * Free collateral represents the amount of collateral that is not backing any liabilities.
-   *
-   * @param opts - Optional configuration
-   * @param opts.clamped - If true, clamps negative values to zero
-   *
-   * @returns The free collateral amount in USD
-   */
-  computeFreeCollateralFromCache(opts) {
-    return computeFreeCollateralFromCache(this, opts);
-  }
-  /**
-   * Computes free collateral from balances using Initial margin requirements.
-   *
-   * Free collateral represents the amount of value available for new borrows or withdrawals.
-   * By default, negative values are clamped to zero.
-   *
-   * @param params - Configuration for free collateral computation (excluding activeBalances)
-   * @returns Free collateral value in USD (clamped to zero by default)
-   */
-  computeFreeCollateralFromBalances(params) {
-    return computeFreeCollateralFromBalances({
-      activeBalances: this.activeBalances,
-      ...params
-    });
-  }
-  /**
-   * Computes health components using cached health values.
-   *
-   * Returns weighted asset and liability values based on the margin requirement type.
-   *
-   * @param marginReqType - The margin requirement type (Initial, Maintenance, or Equity)
-   *
-   * @returns Object containing assets and liabilities values in USD
-   */
-  computeHealthComponentsFromCache(marginRequirement) {
-    return computeHealthComponentsFromCache(this, marginRequirement);
-  }
-  /**
-   * Computes health components from balances with price bias.
-   *
-   * Returns weighted asset and liability values using conservative pricing
-   * (Lowest for assets, Highest for liabilities).
-   *
-   * @param params - Configuration for health computation (excluding activeBalances)
-   * @returns Object containing assets and liabilities values in USD
-   */
-  computeHealthComponentsFromBalances(params) {
-    return computeHealthComponentsFromBalances({
-      activeBalances: this.activeBalances,
-      ...params
-    });
+  /**
+   * Computes health components from balances with price bias.
+   *
+   * Returns weighted asset and liability values using conservative pricing
+   * (Lowest for assets, Highest for liabilities).
+   *
+   * @param params - Configuration for health computation (excluding activeBalances)
+   * @returns Object containing assets and liabilities values in USD
+   */
+  computeHealthComponentsFromBalances(params) {
+    return computeHealthComponentsFromBalances({
+      activeBalances: this.activeBalances,
+      ...params
+    });
   }
   /**
    * Computes the total account value (equity).
@@ -69410,6 +67951,86 @@ var MarginfiAccount = class _MarginfiAccount {
       }
     });
   }
+  /**
+   * Creates a loop transaction with a transparent bridged (double-hop) fallback.
+   *
+   * One call: tries the direct {@link makeLoopTx} first; if its borrow→deposit swap can't fit one
+   * transaction (size / account-locks) or has no route, it loops the deposit asset against a
+   * value-equivalent borrow of a high-liquidity bridge token, then debt-swaps the bridge debt to
+   * the requested borrow asset — both legs composed into ONE atomic Jito bundle.
+   *
+   * Bridge candidates default to USDC → wSOL → USDT and can be reordered/overridden via
+   * `params.bridgeOpts.bridgeCandidateMints`; `bridgeOpts` also accepts known token programs (skips RPC
+   * lookups), a bundle-size ceiling, and an abort signal. `result.bridgeMint` is set only when the
+   * bridged path was used.
+   *
+   * Intended for existing accounts — a fresh account's loop fits the direct path, so flows that
+   * create the account in the same action should call {@link makeLoopTx} directly.
+   *
+   * @param params - Loop transaction parameters plus optional `bridgeOpts`
+   * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+   *
+   * @see {@link makeBridgedLoopTx} for detailed implementation
+   */
+  async makeBridgedLoopTx(params) {
+    return makeBridgedLoopTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
+  /**
+   * Creates a collateral-swap transaction with a transparent bridged (double-hop) fallback.
+   *
+   * One call: tries the direct {@link makeSwapCollateralTx} first; if the swap `A → C` can't fit
+   * one transaction or has no route, it decomposes into `A → bridge` + `bridge → C` through a
+   * high-liquidity bridge collateral, both legs composed into ONE atomic Jito bundle. See
+   * {@link makeBridgedLoopTx} for the `bridgeOpts` knobs.
+   *
+   * @param params - Swap collateral transaction parameters plus optional `bridgeOpts`
+   * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+   *
+   * @see {@link makeBridgedSwapCollateralTx} for detailed implementation
+   */
+  async makeBridgedSwapCollateralTx(params) {
+    return makeBridgedSwapCollateralTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
+  /**
+   * Creates a debt-swap transaction with a transparent bridged (double-hop) fallback.
+   *
+   * One call: tries the direct {@link makeSwapDebtTx} first; if the swap `A → C` can't fit one
+   * transaction or has no route, the first leg repays A by borrowing a bridge token and the second
+   * leg repays exactly that bridge debt while borrowing C — both legs composed into ONE atomic
+   * Jito bundle. See {@link makeBridgedLoopTx} for the `bridgeOpts` knobs.
+   *
+   * @param params - Swap debt transaction parameters plus optional `bridgeOpts`
+   * @returns Object containing transactions, action index, merged swap quote, and the bridge mint
+   *
+   * @see {@link makeBridgedSwapDebtTx} for detailed implementation
+   */
+  async makeBridgedSwapDebtTx(params) {
+    return makeBridgedSwapDebtTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
   /**
    * Creates a transaction to repay debt using collateral.
    *
@@ -69449,425 +68070,2168 @@ var MarginfiAccount = class _MarginfiAccount {
       }
     });
   }
-  /**
-   * Creates a transaction to swap one collateral position to another using a flash loan.
-   *
-   * A swap collateral transaction:
-   * 1. Withdraws existing collateral via flash loan
-   * 2. Swaps collateral to new asset (via Jupiter)
-   * 3. Deposits swapped assets as new collateral
-   *
-   * This allows users to change their collateral type (e.g., JitoSOL -> mSOL) without
-   * withdrawing and affecting their health during the swap.
-   *
-   * @param params - Swap collateral transaction parameters
-   * @param params.connection - Solana connection instance
-   * @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 - Swap configuration (venue, slippage, fees)
-   * @param params.addressLookupTableAccounts - Address lookup tables
-   * @param params.overrideInferAccounts - Optional account overrides
-   * @param params.additionalIxs - Additional instructions to include
-   * @param params.crossbarUrl - Crossbar URL for oracle updates
-   *
-   * @returns Object containing transactions array, action index, and swap quote
-   *
-   * @throws {TransactionBuildingError} If swap exceeds transaction size limits
-   * @throws {TransactionBuildingError} If Kamino reserve not found
-   *
-   * @see {@link makeSwapCollateralTx} for detailed implementation
-   */
-  async makeSwapCollateralTx(params) {
-    return makeSwapCollateralTx({
-      ...params,
-      marginfiAccount: this,
-      overrideInferAccounts: {
-        authority: this.authority,
-        group: this.group,
-        ...params.overrideInferAccounts
-      }
+  /**
+   * Creates a transaction to swap one collateral position to another using a flash loan.
+   *
+   * A swap collateral transaction:
+   * 1. Withdraws existing collateral via flash loan
+   * 2. Swaps collateral to new asset (via Jupiter)
+   * 3. Deposits swapped assets as new collateral
+   *
+   * This allows users to change their collateral type (e.g., JitoSOL -> mSOL) without
+   * withdrawing and affecting their health during the swap.
+   *
+   * @param params - Swap collateral transaction parameters
+   * @param params.connection - Solana connection instance
+   * @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 - Swap configuration (venue, slippage, fees)
+   * @param params.addressLookupTableAccounts - Address lookup tables
+   * @param params.overrideInferAccounts - Optional account overrides
+   * @param params.additionalIxs - Additional instructions to include
+   * @param params.crossbarUrl - Crossbar URL for oracle updates
+   *
+   * @returns Object containing transactions array, action index, and swap quote
+   *
+   * @throws {TransactionBuildingError} If swap exceeds transaction size limits
+   * @throws {TransactionBuildingError} If Kamino reserve not found
+   *
+   * @see {@link makeSwapCollateralTx} for detailed implementation
+   */
+  async makeSwapCollateralTx(params) {
+    return makeSwapCollateralTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
+  /**
+   * Creates a transaction to roll a matured Exponent PT collateral position into its
+   * next-maturity PT, in one flash-loan-wrapped bundle
+   * (withdraw PT_old → `wrapper_merge` to base → swap-engine buy PT_new → deposit).
+   * See {@link makeRollPtTx}.
+   *
+   * @param params - Roll-PT parameters (`withdrawOpts`/`depositOpts`/`swapOpts`/`rollOpts`).
+   */
+  async makeRollPtTx(params) {
+    return makeRollPtTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
+  /**
+   * Creates a transaction to swap one debt position to another using a flash loan.
+   *
+   * A swap debt transaction:
+   * 1. Borrows new asset via flash loan (new debt)
+   * 2. Swaps new asset to old debt asset (via Jupiter)
+   * 3. Repays old debt with swapped assets
+   *
+   * This allows users to change their debt type (e.g., USDC debt -> SOL debt) without
+   * repaying and affecting their health during the swap.
+   *
+   * @param params - Swap debt transaction parameters
+   * @param params.connection - Solana connection instance
+   * @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 - Swap configuration (venue, slippage, fees)
+   * @param params.addressLookupTableAccounts - Address lookup tables
+   * @param params.overrideInferAccounts - Optional account overrides
+   * @param params.additionalIxs - Additional instructions to include
+   * @param params.crossbarUrl - Crossbar URL for oracle updates
+   *
+   * @returns Object containing transactions array, action index, and swap quote
+   *
+   * @throws {TransactionBuildingError} If swap exceeds transaction size limits
+   *
+   * @see {@link makeSwapDebtTx} for detailed implementation
+   */
+  async makeSwapDebtTx(params) {
+    return makeSwapDebtTx({
+      ...params,
+      marginfiAccount: this,
+      overrideInferAccounts: {
+        authority: this.authority,
+        group: this.group,
+        ...params.overrideInferAccounts
+      }
+    });
+  }
+  /**
+   * Creates a deposit transaction.
+   *
+   * @param params - Parameters for the deposit transaction
+   * @returns Promise resolving to an ExtendedTransaction
+   *
+   * @see {@link makeDepositTx} for detailed implementation
+   */
+  async makeDepositTx(params) {
+    return makeDepositTx({
+      ...params,
+      accountAddress: this.address,
+      authority: this.authority,
+      group: this.group
+    });
+  }
+  /**
+   * Creates a Drift deposit transaction.
+   *
+   * @param params - Parameters for the Drift deposit transaction
+   * @returns Promise resolving to an ExtendedV0Transaction
+   *
+   * @see {@link makeDriftDepositTx} for detailed implementation
+   */
+  async makeDriftDepositTx(params) {
+    return makeDriftDepositTx({
+      ...params,
+      accountAddress: this.address,
+      authority: this.authority,
+      group: this.group
+    });
+  }
+  /**
+   * Creates a Kamino deposit transaction.
+   *
+   * @param params - Parameters for the Kamino deposit transaction
+   * @returns Promise resolving to an ExtendedV0Transaction
+   *
+   * @see {@link makeKaminoDepositTx} for detailed implementation
+   */
+  async makeKaminoDepositTx(params) {
+    return makeKaminoDepositTx({
+      ...params,
+      accountAddress: this.address,
+      authority: this.authority,
+      group: this.group
+    });
+  }
+  /**
+   * Creates a borrow transaction.
+   *
+   * @param params - Parameters for the borrow transaction
+   * @returns Promise resolving to a TransactionBuilderResult
+   *
+   * @see {@link makeBorrowTx} for detailed implementation
+   */
+  async makeBorrowTx(params) {
+    return makeBorrowTx({
+      ...params,
+      marginfiAccount: this,
+      opts: {
+        ...params.opts,
+        overrideInferAccounts: {
+          authority: this.authority,
+          ...params.opts?.overrideInferAccounts
+        }
+      }
+    });
+  }
+  /**
+   * Creates a repay transaction.
+   *
+   * @param params - Parameters for the repay transaction
+   * @returns Promise resolving to an ExtendedTransaction
+   *
+   * @see {@link makeRepayTx} for detailed implementation
+   */
+  async makeRepayTx(params) {
+    return makeRepayTx({
+      ...params,
+      accountAddress: this.address,
+      authority: this.authority
+    });
+  }
+  /**
+   * Creates a withdraw transaction.
+   *
+   * @param params - Parameters for the withdraw transaction
+   * @returns Promise resolving to a TransactionBuilderResult
+   *
+   * @see {@link makeWithdrawTx} for detailed implementation
+   */
+  async makeWithdrawTx(params) {
+    return makeWithdrawTx({
+      ...params,
+      marginfiAccount: this,
+      opts: {
+        ...params.opts,
+        overrideInferAccounts: {
+          authority: this.authority,
+          group: this.group,
+          ...params.opts?.overrideInferAccounts
+        }
+      }
+    });
+  }
+  /**
+   * Creates a Drift withdraw transaction.
+   *
+   * @param params - Parameters for the Drift withdraw transaction
+   * @returns Promise resolving to an ExtendedV0Transaction
+   *
+   * @see {@link makeDriftWithdrawTx} for detailed implementation
+   */
+  async makeDriftWithdrawTx(params) {
+    return makeDriftWithdrawTx({
+      ...params,
+      marginfiAccount: this,
+      opts: {
+        ...params.opts,
+        overrideInferAccounts: {
+          authority: this.authority,
+          group: this.group,
+          ...params.opts?.overrideInferAccounts
+        }
+      }
+    });
+  }
+  /**
+   * Creates a Kamino withdraw transaction.
+   *
+   * @param params - Parameters for the Kamino withdraw transaction
+   * @returns Promise resolving to a TransactionBuilderResult
+   *
+   * @see {@link makeKaminoWithdrawTx} for detailed implementation
+   */
+  async makeKaminoWithdrawTx(params) {
+    return makeKaminoWithdrawTx({
+      ...params,
+      marginfiAccount: this,
+      opts: {
+        ...params.opts,
+        overrideInferAccounts: {
+          authority: this.authority,
+          group: this.group,
+          ...params.opts?.overrideInferAccounts
+        }
+      }
+    });
+  }
+  /**
+   * Creates a flash loan transaction.
+   *
+   * @param params - Parameters for the flash loan transaction
+   * @returns Promise resolving to flash loan transaction details
+   *
+   * @see {@link makeFlashLoanTx} for detailed implementation
+   */
+  async makeFlashLoanTx(params) {
+    return makeFlashLoanTx({
+      ...params,
+      marginfiAccount: this
+    });
+  }
+};
+
+// src/services/account/actions/bridge-swap.ts
+var MAX_BRIDGED_BUNDLE_TXS = 5;
+function classifyTxs(txs) {
+  const out = { setups: [], cranks: [], flashloans: [] };
+  for (const tx of txs) {
+    if (tx.type === "CREATE_ATA" /* CREATE_ATA */) out.setups.push(tx);
+    else if (tx.type === "CRANK" /* CRANK */) out.cranks.push(tx);
+    else out.flashloans.push(tx);
+  }
+  return out;
+}
+function ixIdentity(ix) {
+  const keys = ix.keys.map((k) => k.pubkey.toBase58()).join(",");
+  return `${ix.programId.toBase58()}|${keys}|${Buffer.from(ix.data).toString("base64")}`;
+}
+function mergeSetupTxs(txs, payer, blockhash) {
+  if (txs.length === 0) return null;
+  if (txs.length === 1) return txs[0];
+  const lutMap = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const ixs = [];
+  for (const tx of txs) {
+    const luts2 = tx.addressLookupTables ?? [];
+    luts2.forEach((l) => lutMap.set(l.key.toBase58(), l));
+    const msg = decompileV0Transaction(tx, luts2);
+    for (const ix of msg.instructions) {
+      const id = ixIdentity(ix);
+      if (seen.has(id)) continue;
+      seen.add(id);
+      ixs.push(ix);
+    }
+  }
+  const luts = [...lutMap.values()];
+  const split = splitInstructionsToFitTransactions([], ixs, { blockhash, payerKey: payer, luts });
+  if (split.length !== 1) return null;
+  return addTransactionMetadata(split[0], {
+    type: "CREATE_ATA" /* CREATE_ATA */,
+    addressLookupTables: luts
+  });
+}
+function projectAccountAfterFirstLeg(account, firstLegFlashloanTxs, program, banksMap, multipliers) {
+  const ixs = [];
+  for (const tx of firstLegFlashloanTxs) {
+    const luts = tx.addressLookupTables ?? [];
+    ixs.push(...decompileV0Transaction(tx, luts).instructions);
+  }
+  const { projectedBalances } = computeProjectedActiveBalancesNoCpi({
+    account,
+    instructions: ixs,
+    program,
+    banksMap,
+    assetShareValueMultiplierByBank: multipliers
+  });
+  return new MarginfiAccount(
+    account.address,
+    account.group,
+    account.authority,
+    projectedBalances.map((b) => Balance.fromBalanceType(b)),
+    account.accountFlags,
+    account.emissionsDestinationAccount,
+    account.healthCache
+  );
+}
+function composeBundle(firstLegTxs, secondLegTxs, payer, blockhash, maxBundleTxs) {
+  const c1 = classifyTxs(firstLegTxs);
+  const c2 = classifyTxs(secondLegTxs);
+  const mergedSetup = mergeSetupTxs([...c1.setups, ...c2.setups], payer, blockhash);
+  if ([...c1.setups, ...c2.setups].length > 0 && !mergedSetup) return null;
+  const result = [
+    ...mergedSetup ? [mergedSetup] : [],
+    ...c1.cranks,
+    ...c1.flashloans,
+    // firstLegFL(s)
+    ...c2.cranks,
+    ...c2.flashloans
+    // secondLegFL(s)
+  ];
+  if (result.length > maxBundleTxs) return null;
+  return result;
+}
+function compoundQuoteRisk(firstLeg, secondLeg) {
+  const compound = (a, b) => {
+    if (a == null && b == null) return void 0;
+    const x = Number(a ?? 0);
+    const y = Number(b ?? 0);
+    return String(1 - (1 - x) * (1 - y));
+  };
+  return {
+    slippageBps: Math.round(
+      (1 - (1 - firstLeg.slippageBps / 1e4) * (1 - secondLeg.slippageBps / 1e4)) * 1e4
+    ),
+    priceImpactPct: compound(firstLeg.priceImpactPct, secondLeg.priceImpactPct)
+  };
+}
+function mergeBridgeQuotes(firstLeg, secondLeg) {
+  return {
+    inAmount: firstLeg.inAmount,
+    outAmount: secondLeg.outAmount,
+    otherAmountThreshold: secondLeg.otherAmountThreshold,
+    ...compoundQuoteRisk(firstLeg, secondLeg),
+    provider: firstLeg.provider
+  };
+}
+function mergeBridgeQuotesDebt(firstLeg, secondLeg) {
+  return {
+    inAmount: firstLeg.outAmount,
+    outAmount: secondLeg.inAmount,
+    otherAmountThreshold: secondLeg.inAmount,
+    ...compoundQuoteRisk(firstLeg, secondLeg),
+    provider: firstLeg.provider
+  };
+}
+function mergeBridgeQuotesLoop(firstLeg, secondLeg) {
+  return {
+    inAmount: secondLeg.inAmount,
+    outAmount: firstLeg.outAmount,
+    otherAmountThreshold: firstLeg.otherAmountThreshold,
+    ...compoundQuoteRisk(firstLeg, secondLeg),
+    provider: firstLeg.provider
+  };
+}
+function blockhashOf(leg) {
+  const tx = leg.transactions[0];
+  return tx ? tx.message.recentBlockhash : web3_js.PublicKey.default.toBase58();
+}
+async function composeBridgedSwap(params) {
+  const {
+    firstLeg,
+    buildSecondLeg,
+    marginfiAccount,
+    program,
+    banksMap,
+    assetShareValueMultiplierByBank,
+    feePayer,
+    maxBundleTxs = MAX_BRIDGED_BUNDLE_TXS
+  } = params;
+  if (!firstLeg.quoteResponse) return null;
+  const projectedAccount = projectAccountAfterFirstLeg(
+    marginfiAccount,
+    classifyTxs(firstLeg.transactions).flashloans,
+    program,
+    banksMap,
+    assetShareValueMultiplierByBank
+  );
+  const secondLeg = await buildSecondLeg(projectedAccount);
+  if (!secondLeg.quoteResponse) return null;
+  const transactions = composeBundle(
+    firstLeg.transactions,
+    secondLeg.transactions,
+    feePayer,
+    blockhashOf(firstLeg),
+    maxBundleTxs
+  );
+  if (!transactions) return null;
+  return { transactions, firstLegQuote: firstLeg.quoteResponse, secondLegQuote: secondLeg.quoteResponse };
+}
+async function makeSwapDebtTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    repayOpts,
+    borrowOpts,
+    bankMetadataMap,
+    assetShareValueMultiplierByBank,
+    addressLookupTableAccounts,
+    crossbarUrl,
+    additionalIxs = []
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      { mint: repayOpts.repayBank.mint, tokenProgram: repayOpts.tokenProgram },
+      { mint: borrowOpts.borrowBank.mint, tokenProgram: borrowOpts.tokenProgram }
+    ]
+  });
+  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [],
+    bankMetadataMap,
+    [repayOpts.repayBank.address, borrowOpts.borrowBank.address]
+  );
+  const { flashloanTx, setupInstructions, swapQuote, borrowIxs, repayIxs } = await buildSwapDebtFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(repayOpts.repayBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: [...borrowIxs.instructions, ...repayIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (setupIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
+    const ixs = [...additionalIxs, ...setupIxs, ...refreshIntegrationIxs.instructions];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildSwapDebtFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  repayOpts,
+  borrowOpts,
+  swapOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  overrideInferAccounts,
+  blockhash,
+  swapEngineRunner
+}) {
+  const {
+    repayBank,
+    tokenProgram: repayTokenProgram,
+    totalPositionAmount,
+    repayAmount
+  } = repayOpts;
+  const { borrowBank, tokenProgram: borrowTokenProgram } = borrowOpts;
+  if (repayAmount !== void 0 && repayAmount <= 0) {
+    throw new Error("repayAmount must be greater than 0");
+  }
+  const actualRepayAmount = Math.min(repayAmount ?? totalPositionAmount, totalPositionAmount);
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const destinationTokenAccount = getAssociatedTokenAddressSync(
+    repayBank.mint,
+    marginfiAccount.authority,
+    true,
+    repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+  );
+  const estimatedBorrowAmount = computeBorrowEstimateForRepay({
+    repayTargetUi: actualRepayAmount,
+    repayMarketPrice: repayOpts.marketPrice,
+    borrowMarketPrice: borrowOpts.marketPrice,
+    slippageBps: swapOpts.swapConfig?.slippageBps,
+    isRepayAll: actualRepayAmount >= totalPositionAmount
+  });
+  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 footprintBorrowIxs = await makeBorrowIx3({
+    program,
+    bank: borrowBank,
+    bankMap,
+    tokenProgram: borrowTokenProgram,
+    amount: estimatedBorrowAmount,
+    marginfiAccount,
+    authority: marginfiAccount.authority,
+    isSync: true,
+    opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
+  });
+  const footprintRepayIxs = await makeRepayIx3({
+    program,
+    bank: repayBank,
+    tokenProgram: repayTokenProgram,
+    amount: actualRepayAmount,
+    accountAddress: marginfiAccount.address,
+    authority: marginfiAccount.authority,
+    isSync: true,
+    opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+  });
+  const runEngine = swapEngineRunner ?? runSwapEngine;
+  const engineResult = await runEngine({
+    inputMint: borrowBank.mint.toBase58(),
+    outputMint: repayBank.mint.toBase58(),
+    amountNative: uiToNative(estimatedBorrowAmount, borrowBank.mintDecimals).toNumber(),
+    inputDecimals: borrowBank.mintDecimals,
+    outputDecimals: repayBank.mintDecimals,
+    ...swapEngineQuoteFieldsFromOpts(swapOpts),
+    taker: marginfiAccount.authority,
+    destinationTokenAccount,
+    connection,
+    footprint: {
+      instructions: [
+        ...cuRequestIxs,
+        ...footprintBorrowIxs.instructions,
+        ...footprintRepayIxs.instructions
+      ],
+      luts: addressLookupTableAccounts ?? [],
+      payer: marginfiAccount.authority,
+      sizeConstraint: swapConstraints.sizeConstraint,
+      maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
+    },
+    providers: swapEngineProvidersFromOpts(swapOpts)
+  });
+  const quoteResponse = engineResult.quoteResponse;
+  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
+    }
+  });
+  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 ?? [], ...engineResult.swapLuts];
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...borrowIxs.instructions,
+    ...engineResult.swapInstructions,
+    ...repayIxs.instructions
+  ];
+  compileFlashloanPrecheck({
+    allIxs: allNonFlIxs,
+    payer: marginfiAccount.authority,
+    luts,
+    sizeConstraint: swapConstraints.sizeConstraint,
+    swapIxCount: engineResult.swapInstructions.length,
+    swapLutCount: engineResult.swapLuts.length
+  });
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: true
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions: engineResult.setupInstructions,
+    swapQuote: quoteResponse,
+    borrowIxs,
+    repayIxs
+  };
+}
+async function makeBridgedSwapDebtTx(params) {
+  const { bridgeOpts, ...directParams } = params;
+  try {
+    return await makeSwapDebtTx(directParams);
+  } catch (directError) {
+    if (!isDecomposableSwapError(directError)) throw directError;
+    const bridged = await tryBridgedDebtSwap(directParams, bridgeOpts);
+    if (bridged) return bridged;
+    throw directError;
+  }
+}
+async function tryBridgedDebtSwap(params, bridgeOpts) {
+  const sourceBank = params.repayOpts.repayBank;
+  const destinationBank = params.borrowOpts.borrowBank;
+  const repayAmount = params.repayOpts.repayAmount ?? params.repayOpts.totalPositionAmount;
+  const oraclePriceOf = (bank) => params.oraclePrices.get(bank.address.toBase58())?.priceRealtime.price.toNumber() ?? 0;
+  const { usableBridgeBanks, conflictingBridgeBanks } = selectSwapBridges({
+    sourceMint: sourceBank.mint,
+    destinationMint: destinationBank.mint,
+    bankMap: params.bankMap,
+    marginfiAccount: params.marginfiAccount,
+    bridgeTokenSide: "borrow",
+    bridgeCandidateMints: bridgeOpts?.bridgeCandidateMints
+  });
+  const tokenProgramCache = new Map(bridgeOpts?.tokenProgramByMint);
+  return tryBridgeCandidates({
+    usableBridgeBanks,
+    conflictingBridgeBanks,
+    bridgeTokenSide: "borrow",
+    abortSignal: bridgeOpts?.abortSignal,
+    buildBundleThroughBridge: async (bridgeBank) => {
+      const bridgeTokenProgram = await resolveTokenProgramForMint(
+        bridgeBank.mint,
+        params.connection,
+        tokenProgramCache
+      );
+      const firstLeg = await makeSwapDebtTx({
+        ...sharedBridgeLegContext(params),
+        repayOpts: {
+          totalPositionAmount: params.repayOpts.totalPositionAmount,
+          repayAmount,
+          repayBank: sourceBank,
+          tokenProgram: params.repayOpts.tokenProgram,
+          marketPrice: oraclePriceOf(sourceBank)
+        },
+        borrowOpts: {
+          borrowBank: bridgeBank,
+          tokenProgram: bridgeTokenProgram,
+          marketPrice: oraclePriceOf(bridgeBank)
+        }
+      });
+      if (!firstLeg.quoteResponse) return null;
+      const bridgeBorrowedUi = nativeToUi(firstLeg.quoteResponse.inAmount, bridgeBank.mintDecimals);
+      if (bridgeBorrowedUi <= 0) return null;
+      const result = await composeBridgedSwap({
+        firstLeg,
+        buildSecondLeg: (projectedAccount) => makeSwapDebtTx({
+          ...sharedBridgeLegContext(params),
+          marginfiAccount: projectedAccount,
+          repayOpts: {
+            totalPositionAmount: bridgeBorrowedUi,
+            repayAmount: bridgeBorrowedUi,
+            repayBank: bridgeBank,
+            tokenProgram: bridgeTokenProgram,
+            marketPrice: oraclePriceOf(bridgeBank)
+          },
+          borrowOpts: {
+            borrowBank: destinationBank,
+            tokenProgram: params.borrowOpts.tokenProgram,
+            marketPrice: oraclePriceOf(destinationBank)
+          }
+        }),
+        marginfiAccount: params.marginfiAccount,
+        program: params.program,
+        banksMap: params.bankMap,
+        assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+        feePayer: params.overrideInferAccounts?.authority ?? params.marginfiAccount.authority,
+        maxBundleTxs: bridgeOpts?.maxBundleTxs
+      });
+      if (!result) return null;
+      return {
+        transactions: result.transactions,
+        actionTxIndex: result.transactions.length - 1,
+        quoteResponse: mergeBridgeQuotesDebt(result.firstLegQuote, result.secondLegQuote),
+        bridgeMint: bridgeBank.mint
+      };
+    }
+  });
+}
+
+// src/services/account/actions/loop.ts
+async function makeLoopTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    bankMap,
+    depositOpts,
+    borrowOpts,
+    bankMetadataMap,
+    addressLookupTableAccounts,
+    connection,
+    oraclePrices,
+    crossbarUrl,
+    additionalIxs = []
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      {
+        mint: borrowOpts.borrowBank.mint,
+        tokenProgram: borrowOpts.tokenProgram
+      },
+      {
+        mint: depositOpts.depositBank.mint,
+        tokenProgram: depositOpts.tokenProgram
+      }
+    ]
+  });
+  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
+    params.marginfiAccount,
+    params.bankMap,
+    [depositOpts.depositBank.address],
+    params.bankMetadataMap,
+    [borrowOpts.borrowBank.address, depositOpts.depositBank.address]
+  );
+  const { flashloanTx, setupInstructions, swapQuote, depositIxs, borrowIxs } = await buildLoopFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(depositOpts.depositBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+    instructions: [...borrowIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (depositOpts.depositBank.mint.equals(NATIVE_MINT) && depositOpts.inputDepositAmount) {
+    setupIxs.push(
+      ...makeWrapSolIxs(marginfiAccount.authority, new BigNumber3.BigNumber(depositOpts.inputDepositAmount))
+    );
+  }
+  if (setupIxs.length > 0 || additionalIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
+    const ixs = [...additionalIxs, ...setupIxs, ...refreshIntegrationIxs.instructions];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildLoopFlashloanTx(params) {
+  const { depositOpts } = params;
+  const { descriptor, swapNeeded, borrowIxs, depositIxs } = await buildLoopNonSwapIxs(params);
+  if (!swapNeeded) {
+    const flashloanTx2 = await finalizeLoopFlashloanTx({
+      params,
+      innerIxs: descriptor.innerIxs,
+      luts: descriptor.luts,
+      swapIxCount: 0,
+      swapLutCount: 0,
+      sizeConstraint: descriptor.sizeConstraint
     });
+    return {
+      flashloanTx: flashloanTx2,
+      setupInstructions: [],
+      swapQuote: void 0,
+      borrowIxs,
+      depositIxs
+    };
   }
-  /**
-   * Creates a transaction to roll a matured Exponent PT collateral position into its
-   * next-maturity PT, in one flash-loan-wrapped bundle
-   * (withdraw PT_old → `wrapper_merge` to base → swap-engine buy PT_new → deposit).
-   * See {@link makeRollPtTx}.
-   *
-   * @param params - Roll-PT parameters (`withdrawOpts`/`depositOpts`/`swapOpts`/`rollOpts`).
-   */
-  async makeRollPtTx(params) {
-    return makeRollPtTx({
-      ...params,
-      marginfiAccount: this,
-      overrideInferAccounts: {
-        authority: this.authority,
-        group: this.group,
-        ...params.overrideInferAccounts
-      }
+  const engineResult = await runLoopSwapEngine(descriptor, params);
+  const finalIxs = [...descriptor.innerIxs];
+  finalIxs.splice(descriptor.swapSlotIndex, 0, ...engineResult.swapInstructions);
+  const principalNative = depositOpts.loopMode === "DEPOSIT" ? uiToNative(depositOpts.inputDepositAmount, depositOpts.depositBank.mintDecimals) : new BN9__default.default(0);
+  const finalDepositNative = engineResult.outputAmountNative.add(principalNative);
+  const depositIxPosition = descriptor.depositIxIndex + engineResult.swapInstructions.length;
+  patchDepositAmount(finalIxs[depositIxPosition], finalDepositNative);
+  const luts = [...descriptor.luts, ...engineResult.swapLuts];
+  const flashloanTx = await finalizeLoopFlashloanTx({
+    params,
+    innerIxs: finalIxs,
+    luts,
+    swapIxCount: engineResult.swapInstructions.length,
+    swapLutCount: engineResult.swapLuts.length,
+    sizeConstraint: descriptor.sizeConstraint
+  });
+  return {
+    flashloanTx,
+    setupInstructions: engineResult.setupInstructions,
+    swapQuote: engineResult.quoteResponse,
+    borrowIxs,
+    depositIxs
+  };
+}
+async function buildLoopNonSwapIxs(params) {
+  const {
+    program,
+    marginfiAccount,
+    bankMap,
+    borrowOpts,
+    depositOpts,
+    bankMetadataMap,
+    addressLookupTableAccounts,
+    overrideInferAccounts
+  } = params;
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const swapNeeded = !depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint);
+  const destinationTokenAccount = getAssociatedTokenAddressSync(
+    new web3_js.PublicKey(depositOpts.depositBank.mint),
+    marginfiAccount.authority,
+    true,
+    depositOpts.tokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+  );
+  const principalUi = depositOpts.loopMode === "DEPOSIT" ? depositOpts.inputDepositAmount : 0;
+  let depositAmountUi;
+  let sizeConstraint = 0;
+  let maxSwapTotalAccounts = 0;
+  if (!swapNeeded) {
+    depositAmountUi = borrowOpts.borrowAmount + principalUi;
+  } else {
+    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
     });
+    sizeConstraint = swapConstraints.sizeConstraint;
+    maxSwapTotalAccounts = swapConstraints.maxSwapTotalAccounts;
+    const estimateUi = borrowOpts.borrowAmount * borrowOpts.marketPrice / depositOpts.marketPrice;
+    depositAmountUi = estimateUi + principalUi;
   }
-  /**
-   * Creates a transaction to swap one debt position to another using a flash loan.
-   *
-   * A swap debt transaction:
-   * 1. Borrows new asset via flash loan (new debt)
-   * 2. Swaps new asset to old debt asset (via Jupiter)
-   * 3. Repays old debt with swapped assets
-   *
-   * This allows users to change their debt type (e.g., USDC debt -> SOL debt) without
-   * repaying and affecting their health during the swap.
-   *
-   * @param params - Swap debt transaction parameters
-   * @param params.connection - Solana connection instance
-   * @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 - Swap configuration (venue, slippage, fees)
-   * @param params.addressLookupTableAccounts - Address lookup tables
-   * @param params.overrideInferAccounts - Optional account overrides
-   * @param params.additionalIxs - Additional instructions to include
-   * @param params.crossbarUrl - Crossbar URL for oracle updates
-   *
-   * @returns Object containing transactions array, action index, and swap quote
-   *
-   * @throws {TransactionBuildingError} If swap exceeds transaction size limits
-   *
-   * @see {@link makeSwapDebtTx} for detailed implementation
-   */
-  async makeSwapDebtTx(params) {
-    return makeSwapDebtTx({
-      ...params,
-      marginfiAccount: this,
-      overrideInferAccounts: {
-        authority: this.authority,
-        group: this.group,
-        ...params.overrideInferAccounts
+  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
+    }
+  });
+  const depositIxs = await buildDepositIxs(params, depositAmountUi);
+  const innerIxsBeforeSwap = [...cuRequestIxs, ...borrowIxs.instructions];
+  const swapSlotIndex = innerIxsBeforeSwap.length;
+  const innerIxs = [...innerIxsBeforeSwap, ...depositIxs.instructions];
+  const depositIxIndex = innerIxs.findIndex(isDepositIx);
+  if (depositIxIndex < 0) {
+    throw new Error(
+      "buildLoopNonSwapIxs: could not locate deposit instruction for amount patching"
+    );
+  }
+  const descriptor = {
+    innerIxs,
+    swapSlotIndex,
+    depositIxIndex,
+    inputMint: borrowOpts.borrowBank.mint.toBase58(),
+    outputMint: depositOpts.depositBank.mint.toBase58(),
+    inputDecimals: borrowOpts.borrowBank.mintDecimals,
+    outputDecimals: depositOpts.depositBank.mintDecimals,
+    inAmountNative: uiToNative(
+      borrowOpts.borrowAmount,
+      borrowOpts.borrowBank.mintDecimals
+    ).toNumber(),
+    destinationTokenAccount,
+    sizeConstraint,
+    maxSwapTotalAccounts,
+    luts: addressLookupTableAccounts ?? []
+  };
+  return { descriptor, swapNeeded, borrowIxs, depositIxs };
+}
+async function buildDepositIxs(params, amountUi) {
+  const { program, marginfiAccount, depositOpts, bankMetadataMap, overrideInferAccounts } = params;
+  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
+        );
       }
-    });
+      return makeKaminoDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountUi,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        reserve,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+    }
+    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
+        );
+      }
+      return makeDriftDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountUi,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        driftMarketIndex: driftState.spotMarketState.marketIndex,
+        driftOracle: driftState.spotMarketState.oracle,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+    }
+    case 6 /* JUPLEND */: {
+      return makeJuplendDepositIx2({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountUi,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+    }
+    default: {
+      return makeDepositIx3({
+        program,
+        bank: depositOpts.depositBank,
+        tokenProgram: depositOpts.tokenProgram,
+        amount: amountUi,
+        accountAddress: marginfiAccount.address,
+        authority: marginfiAccount.authority,
+        group: marginfiAccount.group,
+        opts: {
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+    }
   }
-  /**
-   * Creates a deposit transaction.
-   *
-   * @param params - Parameters for the deposit transaction
-   * @returns Promise resolving to an ExtendedTransaction
-   *
-   * @see {@link makeDepositTx} for detailed implementation
-   */
-  async makeDepositTx(params) {
-    return makeDepositTx({
-      ...params,
-      accountAddress: this.address,
-      authority: this.authority,
-      group: this.group
-    });
+}
+async function runLoopSwapEngine(descriptor, params) {
+  const { connection, swapOpts, marginfiAccount, swapEngineRunner } = params;
+  if (swapOpts.swapIxs) {
+    return {
+      swapInstructions: swapOpts.swapIxs.instructions,
+      setupInstructions: [],
+      swapLuts: swapOpts.swapIxs.lookupTables,
+      quoteResponse: {
+        inAmount: String(descriptor.inAmountNative),
+        outAmount: "0",
+        otherAmountThreshold: "0",
+        slippageBps: 0
+      },
+      outputAmountNative: new BN9__default.default(0)
+    };
   }
-  /**
-   * Creates a Drift deposit transaction.
-   *
-   * @param params - Parameters for the Drift deposit transaction
-   * @returns Promise resolving to an ExtendedV0Transaction
-   *
-   * @see {@link makeDriftDepositTx} for detailed implementation
-   */
-  async makeDriftDepositTx(params) {
-    return makeDriftDepositTx({
-      ...params,
-      accountAddress: this.address,
-      authority: this.authority,
-      group: this.group
+  const runEngine = swapEngineRunner ?? runSwapEngine;
+  const engineResult = await runEngine({
+    inputMint: descriptor.inputMint,
+    outputMint: descriptor.outputMint,
+    amountNative: descriptor.inAmountNative,
+    inputDecimals: descriptor.inputDecimals,
+    outputDecimals: descriptor.outputDecimals,
+    ...swapEngineQuoteFieldsFromOpts(swapOpts),
+    taker: marginfiAccount.authority,
+    destinationTokenAccount: descriptor.destinationTokenAccount,
+    connection,
+    footprint: {
+      instructions: descriptor.innerIxs,
+      luts: descriptor.luts,
+      payer: marginfiAccount.authority,
+      sizeConstraint: descriptor.sizeConstraint,
+      maxSwapTotalAccounts: descriptor.maxSwapTotalAccounts
+    },
+    providers: swapEngineProvidersFromOpts(swapOpts)
+  });
+  return {
+    swapInstructions: engineResult.swapInstructions,
+    setupInstructions: engineResult.setupInstructions,
+    swapLuts: engineResult.swapLuts,
+    quoteResponse: engineResult.quoteResponse,
+    outputAmountNative: engineResult.outputAmountNative
+  };
+}
+async function finalizeLoopFlashloanTx({
+  params,
+  innerIxs,
+  luts,
+  swapIxCount,
+  swapLutCount,
+  sizeConstraint
+}) {
+  const { program, marginfiAccount, bankMap, swapOpts, blockhash } = params;
+  if (swapIxCount > 0) {
+    compileFlashloanPrecheck({
+      allIxs: innerIxs,
+      payer: marginfiAccount.authority,
+      luts,
+      sizeConstraint,
+      swapIxCount,
+      swapLutCount
     });
   }
-  /**
-   * Creates a Kamino deposit transaction.
-   *
-   * @param params - Parameters for the Kamino deposit transaction
-   * @returns Promise resolving to an ExtendedV0Transaction
-   *
-   * @see {@link makeKaminoDepositTx} for detailed implementation
-   */
-  async makeKaminoDepositTx(params) {
-    return makeKaminoDepositTx({
-      ...params,
-      accountAddress: this.address,
-      authority: this.authority,
-      group: this.group
-    });
+  const flashloanTx = await makeFlashLoanTx({
+    program,
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: innerIxs
+  });
+  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
+    );
   }
-  /**
-   * Creates a borrow transaction.
-   *
-   * @param params - Parameters for the borrow transaction
-   * @returns Promise resolving to a TransactionBuilderResult
-   *
-   * @see {@link makeBorrowTx} for detailed implementation
-   */
-  async makeBorrowTx(params) {
-    return makeBorrowTx({
-      ...params,
-      marginfiAccount: this,
-      opts: {
-        ...params.opts,
-        overrideInferAccounts: {
-          authority: this.authority,
-          ...params.opts?.overrideInferAccounts
+  return flashloanTx;
+}
+async function makeBridgedLoopTx(params) {
+  const { bridgeOpts, ...loopParams } = params;
+  try {
+    return await makeLoopTx(loopParams);
+  } catch (directError) {
+    if (!isDecomposableSwapError(directError)) throw directError;
+    const bridged = await tryBridgedLoop(loopParams, bridgeOpts);
+    if (bridged) return bridged;
+    throw directError;
+  }
+}
+async function tryBridgedLoop(params, bridgeOpts) {
+  const { depositBank } = params.depositOpts;
+  const { borrowBank } = params.borrowOpts;
+  const { usableBridgeBanks, conflictingBridgeBanks } = selectSwapBridges({
+    sourceMint: depositBank.mint,
+    destinationMint: borrowBank.mint,
+    bankMap: params.bankMap,
+    marginfiAccount: params.marginfiAccount,
+    bridgeTokenSide: "borrow",
+    bridgeCandidateMints: bridgeOpts?.bridgeCandidateMints
+  });
+  const oraclePriceOf = (bank) => params.oraclePrices.get(bank.address.toBase58())?.priceRealtime.price.toNumber() ?? 0;
+  const borrowBankPrice = oraclePriceOf(borrowBank);
+  if (borrowBankPrice <= 0) return null;
+  const tokenProgramCache = new Map(bridgeOpts?.tokenProgramByMint);
+  return tryBridgeCandidates({
+    usableBridgeBanks,
+    conflictingBridgeBanks,
+    bridgeTokenSide: "borrow",
+    abortSignal: bridgeOpts?.abortSignal,
+    buildBundleThroughBridge: async (bridgeBank) => {
+      const bridgeBankPrice = oraclePriceOf(bridgeBank);
+      if (bridgeBankPrice <= 0) return null;
+      const bridgeBorrowUi = params.borrowOpts.borrowAmount * borrowBankPrice / bridgeBankPrice;
+      if (bridgeBorrowUi <= 0) return null;
+      const bridgeTokenProgram = await resolveTokenProgramForMint(
+        bridgeBank.mint,
+        params.connection,
+        tokenProgramCache
+      );
+      const firstLeg = await makeLoopTx({
+        ...params,
+        depositOpts: {
+          ...params.depositOpts,
+          marketPrice: oraclePriceOf(depositBank)
+        },
+        borrowOpts: {
+          borrowAmount: bridgeBorrowUi,
+          borrowBank: bridgeBank,
+          tokenProgram: bridgeTokenProgram,
+          marketPrice: bridgeBankPrice
         }
+      });
+      if (!firstLeg.quoteResponse) return null;
+      const result = await composeBridgedSwap({
+        firstLeg,
+        // Second leg: debt-swap the bridge debt → X (repay exactly the bridge the first leg
+        // borrowed — exact, so no slippage residual; repay-all clears it — and borrow X).
+        buildSecondLeg: (projectedAccount) => makeSwapDebtTx({
+          ...sharedBridgeLegContext(params),
+          marginfiAccount: projectedAccount,
+          repayOpts: {
+            totalPositionAmount: bridgeBorrowUi,
+            repayAmount: bridgeBorrowUi,
+            repayBank: bridgeBank,
+            tokenProgram: bridgeTokenProgram,
+            marketPrice: bridgeBankPrice
+          },
+          borrowOpts: {
+            borrowBank,
+            tokenProgram: params.borrowOpts.tokenProgram,
+            marketPrice: borrowBankPrice
+          }
+        }),
+        marginfiAccount: params.marginfiAccount,
+        program: params.program,
+        banksMap: params.bankMap,
+        assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+        feePayer: params.overrideInferAccounts?.authority ?? params.marginfiAccount.authority,
+        maxBundleTxs: bridgeOpts?.maxBundleTxs
+      });
+      if (!result) return null;
+      return {
+        transactions: result.transactions,
+        actionTxIndex: result.transactions.length - 1,
+        quoteResponse: mergeBridgeQuotesLoop(result.firstLegQuote, result.secondLegQuote),
+        bridgeMint: bridgeBank.mint
+      };
+    }
+  });
+}
+async function makeSwapCollateralTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    withdrawOpts,
+    depositOpts,
+    bankMetadataMap,
+    assetShareValueMultiplierByBank,
+    addressLookupTableAccounts,
+    crossbarUrl,
+    additionalIxs = []
+  } = params;
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
+      { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
+    ]
+  });
+  const refreshIntegrationIxs = makeRefreshIntegrationBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address, depositOpts.depositBank.address],
+    bankMetadataMap
+  );
+  const { flashloanTx, setupInstructions, swapQuote, withdrawIxs, depositIxs } = await buildSwapCollateralFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(depositOpts.depositBank.mint)) {
+        return false;
       }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (setupIxs.length > 0 || refreshIntegrationIxs.instructions.length > 0) {
+    const ixs = [...setupIxs, ...refreshIntegrationIxs.instructions];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
     });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
   }
-  /**
-   * Creates a repay transaction.
-   *
-   * @param params - Parameters for the repay transaction
-   * @returns Promise resolving to an ExtendedTransaction
-   *
-   * @see {@link makeRepayTx} for detailed implementation
-   */
-  async makeRepayTx(params) {
-    return makeRepayTx({
-      ...params,
-      accountAddress: this.address,
-      authority: this.authority
-    });
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
   }
-  /**
-   * Creates a withdraw transaction.
-   *
-   * @param params - Parameters for the withdraw transaction
-   * @returns Promise resolving to a TransactionBuilderResult
-   *
-   * @see {@link makeWithdrawTx} for detailed implementation
-   */
-  async makeWithdrawTx(params) {
-    return makeWithdrawTx({
-      ...params,
-      marginfiAccount: this,
-      opts: {
-        ...params.opts,
-        overrideInferAccounts: {
-          authority: this.authority,
-          group: this.group,
-          ...params.opts?.overrideInferAccounts
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildSwapCollateralFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  withdrawOpts,
+  depositOpts,
+  swapOpts,
+  bankMetadataMap,
+  assetShareValueMultiplierByBank,
+  addressLookupTableAccounts,
+  connection,
+  overrideInferAccounts,
+  blockhash,
+  swapEngineRunner
+}) {
+  const {
+    withdrawBank,
+    tokenProgram: withdrawTokenProgram,
+    totalPositionAmount,
+    withdrawAmount
+  } = withdrawOpts;
+  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
+  if (withdrawAmount !== void 0 && withdrawAmount <= 0) {
+    throw new Error("withdrawAmount must be greater than 0");
+  }
+  const actualWithdrawAmount = Math.min(withdrawAmount ?? totalPositionAmount, totalPositionAmount);
+  const isFullWithdraw = isWholePosition(
+    { amount: totalPositionAmount, isLending: true },
+    actualWithdrawAmount,
+    withdrawBank.mintDecimals
+  );
+  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 */: {
+      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(actualWithdrawAmount).div(multiplier).times(1.0001).toNumber();
+      withdrawIxs = await makeKaminoWithdrawIx3({
+        program,
+        bank: withdrawBank,
+        bankMap,
+        tokenProgram: withdrawTokenProgram,
+        cTokenAmount: adjustedAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        reserve,
+        withdrawAll: isFullWithdraw,
+        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
+        );
       }
-    });
-  }
-  /**
-   * Creates a Drift withdraw transaction.
-   *
-   * @param params - Parameters for the Drift withdraw transaction
-   * @returns Promise resolving to an ExtendedV0Transaction
-   *
-   * @see {@link makeDriftWithdrawTx} for detailed implementation
-   */
-  async makeDriftWithdrawTx(params) {
-    return makeDriftWithdrawTx({
-      ...params,
-      marginfiAccount: this,
-      opts: {
-        ...params.opts,
-        overrideInferAccounts: {
-          authority: this.authority,
-          group: this.group,
-          ...params.opts?.overrideInferAccounts
+      withdrawIxs = await makeDriftWithdrawIx3({
+        program,
+        bank: withdrawOpts.withdrawBank,
+        bankMap,
+        tokenProgram: withdrawOpts.tokenProgram,
+        amount: actualWithdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: isFullWithdraw,
+        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: withdrawBank,
+        bankMap,
+        tokenProgram: withdrawTokenProgram,
+        amount: actualWithdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        jupLendingState: jupLendState.jupLendingState,
+        withdrawAll: isFullWithdraw,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
+    default: {
+      withdrawIxs = await makeWithdrawIx3({
+        program,
+        bank: withdrawBank,
+        bankMap,
+        tokenProgram: withdrawTokenProgram,
+        amount: actualWithdrawAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        withdrawAll: isFullWithdraw,
+        isSync: false,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
+    }
   }
-  /**
-   * Creates a Kamino withdraw transaction.
-   *
-   * @param params - Parameters for the Kamino withdraw transaction
-   * @returns Promise resolving to a TransactionBuilderResult
-   *
-   * @see {@link makeKaminoWithdrawTx} for detailed implementation
-   */
-  async makeKaminoWithdrawTx(params) {
-    return makeKaminoWithdrawTx({
-      ...params,
-      marginfiAccount: this,
-      opts: {
-        ...params.opts,
-        overrideInferAccounts: {
-          authority: this.authority,
-          group: this.group,
-          ...params.opts?.overrideInferAccounts
+  const swapNeeded = !depositBank.mint.equals(withdrawBank.mint);
+  amountToDeposit = swapNeeded ? 0 : actualWithdrawAmount;
+  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;
+    }
+    case 4 /* DRIFT */: {
+      const driftState = bankMetadataMap[depositBank.address.toBase58()]?.driftStates;
+      if (!driftState) {
+        throw TransactionBuildingError.driftStateNotFound(
+          depositBank.address.toBase58(),
+          depositBank.mint.toBase58(),
+          depositBank.tokenSymbol
+        );
       }
+      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;
+    }
+  }
+  if (swapNeeded) {
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      depositBank.mint,
+      marginfiAccount.authority,
+      true,
+      depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+    );
+    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
+    });
+    sizeConstraintUsed = swapConstraints.sizeConstraint;
+    const runEngine = swapEngineRunner ?? runSwapEngine;
+    const engineResult = await runEngine({
+      inputMint: withdrawBank.mint.toBase58(),
+      outputMint: depositBank.mint.toBase58(),
+      amountNative: uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toNumber(),
+      inputDecimals: withdrawBank.mintDecimals,
+      outputDecimals: depositBank.mintDecimals,
+      ...swapEngineQuoteFieldsFromOpts(swapOpts),
+      taker: marginfiAccount.authority,
+      destinationTokenAccount,
+      connection,
+      footprint: {
+        instructions: [...cuRequestIxs, ...withdrawIxs.instructions, ...depositIxs.instructions],
+        luts: addressLookupTableAccounts ?? [],
+        payer: marginfiAccount.authority,
+        sizeConstraint: swapConstraints.sizeConstraint,
+        maxSwapTotalAccounts: swapConstraints.maxSwapTotalAccounts
+      },
+      providers: swapEngineProvidersFromOpts(swapOpts)
     });
+    const depositIxToPatch = depositIxs.instructions.find(isDepositIx);
+    if (!depositIxToPatch) {
+      throw new Error("swap-collateral: could not locate deposit instruction for amount patching");
+    }
+    patchDepositAmount(depositIxToPatch, engineResult.outputAmountNative);
+    swapInstructions = engineResult.swapInstructions;
+    setupInstructions = engineResult.setupInstructions;
+    swapLookupTables = engineResult.swapLuts;
+    swapQuote = engineResult.quoteResponse;
   }
-  /**
-   * Creates a flash loan transaction.
-   *
-   * @param params - Parameters for the flash loan transaction
-   * @returns Promise resolving to flash loan transaction details
-   *
-   * @see {@link makeFlashLoanTx} for detailed implementation
-   */
-  async makeFlashLoanTx(params) {
-    return makeFlashLoanTx({
-      ...params,
-      marginfiAccount: this
+  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: false
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(
+      txSize,
+      totalKeys,
+      swapOpts.swapConfig?.provider
+    );
+  }
+  return {
+    flashloanTx,
+    setupInstructions,
+    swapQuote,
+    withdrawIxs,
+    depositIxs
+  };
+}
+var SECOND_LEG_ROUNDING_HEADROOM_NATIVE = 10;
+async function makeBridgedSwapCollateralTx(params) {
+  const { bridgeOpts, ...directParams } = params;
+  try {
+    return await makeSwapCollateralTx(directParams);
+  } catch (directError) {
+    if (!isDecomposableSwapError(directError)) throw directError;
+    const bridged = await tryBridgedCollateralSwap(directParams, bridgeOpts);
+    if (bridged) return bridged;
+    throw directError;
+  }
+}
+async function tryBridgedCollateralSwap(params, bridgeOpts) {
+  const sourceBank = params.withdrawOpts.withdrawBank;
+  const destinationBank = params.depositOpts.depositBank;
+  const withdrawAmount = params.withdrawOpts.withdrawAmount ?? params.withdrawOpts.totalPositionAmount;
+  const { usableBridgeBanks, conflictingBridgeBanks } = selectSwapBridges({
+    sourceMint: sourceBank.mint,
+    destinationMint: destinationBank.mint,
+    bankMap: params.bankMap,
+    marginfiAccount: params.marginfiAccount,
+    bridgeTokenSide: "deposit",
+    bridgeCandidateMints: bridgeOpts?.bridgeCandidateMints
+  });
+  const tokenProgramCache = new Map(bridgeOpts?.tokenProgramByMint);
+  return tryBridgeCandidates({
+    usableBridgeBanks,
+    conflictingBridgeBanks,
+    bridgeTokenSide: "deposit",
+    abortSignal: bridgeOpts?.abortSignal,
+    buildBundleThroughBridge: async (bridgeBank) => {
+      const bridgeTokenProgram = await resolveTokenProgramForMint(
+        bridgeBank.mint,
+        params.connection,
+        tokenProgramCache
+      );
+      const firstLeg = await makeSwapCollateralTx({
+        ...sharedBridgeLegContext(params),
+        withdrawOpts: {
+          totalPositionAmount: params.withdrawOpts.totalPositionAmount,
+          withdrawAmount,
+          withdrawBank: sourceBank,
+          tokenProgram: params.withdrawOpts.tokenProgram
+        },
+        depositOpts: { depositBank: bridgeBank, tokenProgram: bridgeTokenProgram }
+      });
+      if (!firstLeg.quoteResponse) return null;
+      const bridgeMinOutNative = Number(firstLeg.quoteResponse.otherAmountThreshold);
+      const secondLegAmountNative = bridgeMinOutNative - SECOND_LEG_ROUNDING_HEADROOM_NATIVE;
+      if (secondLegAmountNative <= 0) return null;
+      const secondLegAmountUi = nativeToUi(secondLegAmountNative, bridgeBank.mintDecimals);
+      const hasBridgeDeposit = params.marginfiAccount.balances.some(
+        (b) => b.active && b.bankPk.equals(bridgeBank.address) && b.assetShares.gt(0)
+      );
+      const result = await composeBridgedSwap({
+        firstLeg,
+        // The second leg builds against the first leg's projected effect.
+        buildSecondLeg: (projectedAccount) => makeSwapCollateralTx({
+          ...sharedBridgeLegContext(params),
+          marginfiAccount: projectedAccount,
+          withdrawOpts: {
+            totalPositionAmount: hasBridgeDeposit ? nativeToUi(bridgeMinOutNative, bridgeBank.mintDecimals) : secondLegAmountUi,
+            withdrawAmount: secondLegAmountUi,
+            withdrawBank: bridgeBank,
+            tokenProgram: bridgeTokenProgram
+          },
+          depositOpts: params.depositOpts
+        }),
+        marginfiAccount: params.marginfiAccount,
+        program: params.program,
+        banksMap: params.bankMap,
+        assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+        feePayer: params.overrideInferAccounts?.authority ?? params.marginfiAccount.authority,
+        maxBundleTxs: bridgeOpts?.maxBundleTxs
+      });
+      if (!result) return null;
+      return {
+        transactions: result.transactions,
+        actionTxIndex: result.transactions.length - 1,
+        quoteResponse: mergeBridgeQuotes(result.firstLegQuote, result.secondLegQuote),
+        bridgeMint: bridgeBank.mint
+      };
+    }
+  });
+}
+var DEFAULT_ROLL_SLIPPAGE_BPS = 50;
+var TRADE_PT_EVENT_AMOUNT_OUT_OFFSET = 138;
+var MERGE_EVENT_AMOUNT_SY_OUT_OFFSET = 296;
+async function makeRollPtTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    withdrawOpts,
+    depositOpts,
+    rollOpts,
+    assetShareValueMultiplierByBank,
+    addressLookupTableAccounts,
+    crossbarUrl
+  } = params;
+  if (!rollOpts.maturedMarket && !rollOpts.maturedVault) {
+    throw new Error("roll-pt: rollOpts.maturedMarket or maturedVault is required");
+  }
+  const merge = await resolveExponentMergeContext({
+    connection,
+    owner: marginfiAccount.authority,
+    market: rollOpts.maturedMarket,
+    vault: rollOpts.maturedVault,
+    ptYtTokenProgram: withdrawOpts.tokenProgram,
+    syTokenProgram: rollOpts.syTokenProgram
+  });
+  const clmm = await resolveExponentClmmTradePtContext({
+    connection,
+    owner: marginfiAccount.authority,
+    market: rollOpts.successorMarket,
+    ptTokenProgram: depositOpts.tokenProgram,
+    syTokenProgram: rollOpts.syTokenProgram
+  });
+  const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority: marginfiAccount.authority,
+    tokens: [
+      { mint: withdrawOpts.withdrawBank.mint, tokenProgram: withdrawOpts.tokenProgram },
+      { mint: merge.mergeAccounts.mintYt, tokenProgram: withdrawOpts.tokenProgram },
+      { mint: merge.underlying.mint, tokenProgram: merge.underlying.tokenProgram },
+      { mint: depositOpts.depositBank.mint, tokenProgram: depositOpts.tokenProgram }
+    ]
+  });
+  const { flashloanTx, swapQuote, withdrawIxs, depositIxs } = await buildRollPtFlashloanTx({
+    params,
+    merge,
+    clmm,
+    setupIxs,
+    blockhash
+  });
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  const additionalTxs = [];
+  if (setupIxs.length > 0) {
+    const txs = splitInstructionsToFitTransactions([], setupIxs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
     });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
   }
-};
-
-// src/services/account/actions/bridge-swap.ts
-var MAX_BRIDGED_BUNDLE_TXS = 5;
-function classifyTxs(txs) {
-  const out = { setups: [], cranks: [], flashloans: [] };
-  for (const tx of txs) {
-    if (tx.type === "CREATE_ATA" /* CREATE_ATA */) out.setups.push(tx);
-    else if (tx.type === "CRANK" /* CRANK */) out.cranks.push(tx);
-    else out.flashloans.push(tx);
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
   }
-  return out;
-}
-function ixIdentity(ix) {
-  const keys = ix.keys.map((k) => k.pubkey.toBase58()).join(",");
-  return `${ix.programId.toBase58()}|${keys}|${Buffer.from(ix.data).toString("base64")}`;
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
 }
-function mergeSetupTxs(txs, payer, blockhash) {
-  if (txs.length === 0) return null;
-  if (txs.length === 1) return txs[0];
-  const lutMap = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  const ixs = [];
-  for (const tx of txs) {
-    const luts2 = tx.addressLookupTables ?? [];
-    luts2.forEach((l) => lutMap.set(l.key.toBase58(), l));
-    const msg = decompileV0Transaction(tx, luts2);
-    for (const ix of msg.instructions) {
-      const id = ixIdentity(ix);
-      if (seen.has(id)) continue;
-      seen.add(id);
-      ixs.push(ix);
-    }
+async function buildRollPtFlashloanTx({
+  params,
+  merge,
+  clmm,
+  setupIxs,
+  blockhash
+}) {
+  const {
+    program,
+    marginfiAccount,
+    bankMap,
+    withdrawOpts,
+    depositOpts,
+    bankMetadataMap,
+    connection,
+    addressLookupTableAccounts,
+    overrideInferAccounts,
+    rollOpts
+  } = params;
+  const { withdrawBank, tokenProgram: withdrawTokenProgram, totalPositionAmount, withdrawAmount } = withdrawOpts;
+  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
+  const authority = marginfiAccount.authority;
+  if (withdrawAmount !== void 0 && withdrawAmount <= 0) {
+    throw new Error("withdrawAmount must be greater than 0");
   }
-  const luts = [...lutMap.values()];
-  const split = splitInstructionsToFitTransactions([], ixs, { blockhash, payerKey: payer, luts });
-  if (split.length !== 1) return null;
-  return addTransactionMetadata(split[0], {
-    type: "CREATE_ATA" /* CREATE_ATA */,
-    addressLookupTables: luts
+  const actualWithdrawAmount = Math.min(withdrawAmount ?? totalPositionAmount, totalPositionAmount);
+  const isFullWithdraw = isWholePosition(
+    { amount: totalPositionAmount, isLending: true },
+    actualWithdrawAmount,
+    withdrawBank.mintDecimals
+  );
+  const withdrawNative = BigInt(
+    uiToNative(actualWithdrawAmount, withdrawBank.mintDecimals).toString()
+  );
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const withdrawIxs = await makeWithdrawIx3({
+    program,
+    bank: withdrawBank,
+    bankMap,
+    tokenProgram: withdrawTokenProgram,
+    amount: actualWithdrawAmount,
+    marginfiAccount,
+    authority,
+    withdrawAll: isFullWithdraw,
+    isSync: false,
+    opts: { createAtas: false, wrapAndUnwrapSol: false, overrideInferAccounts }
   });
-}
-function projectAccountAfterFirstLeg(account, firstLegFlashloanTxs, program, banksMap, multipliers) {
-  const ixs = [];
-  for (const tx of firstLegFlashloanTxs) {
-    const luts = tx.addressLookupTables ?? [];
-    ixs.push(...decompileV0Transaction(tx, luts).instructions);
+  const mergeIx = makeExponentMergeIx(merge.mergeAccounts, withdrawNative);
+  const depositIxs = await makeDepositIx3({
+    program,
+    bank: depositBank,
+    tokenProgram: depositTokenProgram,
+    amount: 0,
+    accountAddress: marginfiAccount.address,
+    authority,
+    group: marginfiAccount.group,
+    opts: { wrapAndUnwrapSol: false, overrideInferAccounts }
+  });
+  let luts;
+  if (rollOpts.lookupTable) {
+    const fetched = (await connection.getAddressLookupTable(rollOpts.lookupTable)).value;
+    if (!fetched) {
+      throw new Error(`roll-pt: PT-roll lookup table not found: ${rollOpts.lookupTable.toBase58()}`);
+    }
+    luts = [fetched, merge.addressLookupTable, clmm.addressLookupTable];
+  } else {
+    luts = [
+      ...addressLookupTableAccounts ?? [],
+      merge.addressLookupTable,
+      clmm.addressLookupTable
+    ];
   }
-  const { projectedBalances } = computeProjectedActiveBalancesNoCpi({
-    account,
-    instructions: ixs,
+  const redeemIxs = [...setupIxs, ...cuRequestIxs, ...withdrawIxs.instructions, mergeIx];
+  const mergeReturn = await simulateRollReturn({
     program,
-    banksMap,
-    assetShareValueMultiplierByBank: multipliers
+    marginfiAccount,
+    bankMap,
+    connection,
+    blockhash,
+    luts,
+    ixs: redeemIxs,
+    programId: EXPONENT_CORE_PROGRAM_ID,
+    label: "merge"
   });
-  return new MarginfiAccount(
-    account.address,
-    account.group,
-    account.authority,
-    projectedBalances.map((b) => Balance.fromBalanceType(b)),
-    account.accountFlags,
-    account.emissionsDestinationAccount,
-    account.healthCache
+  const syExact = readReturnU64(mergeReturn, MERGE_EVENT_AMOUNT_SY_OUT_OFFSET, "merge amount_sy_out");
+  if (syExact <= 0n) {
+    throw new Error("roll-pt: merge would redeem 0 SY (empty/invalid matured vault state)");
+  }
+  const exactPtOut = await quoteClmmTradeOut({
+    connection,
+    clmm,
+    amountInSyNative: syExact,
+    payer: authority
+  });
+  const slippageBps = rollOpts.slippageBps ?? DEFAULT_ROLL_SLIPPAGE_BPS;
+  const minPtOut = exactPtOut * BigInt(1e4 - slippageBps) / 10000n;
+  if (minPtOut <= 0n) {
+    throw new Error("roll-pt: quoted PT out is 0 (insufficient CLMM liquidity for this size)");
+  }
+  const tradeIx = makeExponentClmmTradePtIx(
+    clmm.tradePtAccounts,
+    exponentClmmBuyPtArgs({ amountInSyNative: syExact, minPtOutNative: minPtOut })
   );
-}
-function composeBundle(firstLegTxs, secondLegTxs, payer, blockhash, maxBundleTxs) {
-  const c1 = classifyTxs(firstLegTxs);
-  const c2 = classifyTxs(secondLegTxs);
-  const mergedSetup = mergeSetupTxs([...c1.setups, ...c2.setups], payer, blockhash);
-  if ([...c1.setups, ...c2.setups].length > 0 && !mergedSetup) return null;
-  const result = [
-    ...mergedSetup ? [mergedSetup] : [],
-    ...c1.cranks,
-    ...c1.flashloans,
-    // firstLegFL(s)
-    ...c2.cranks,
-    ...c2.flashloans
-    // secondLegFL(s)
+  const depositIxToPatch = depositIxs.instructions.find(isDepositIx);
+  if (!depositIxToPatch) {
+    throw new Error("roll-pt: could not locate deposit instruction for amount patching");
+  }
+  patchDepositAmount(depositIxToPatch, new BN9__default.default(minPtOut.toString()));
+  const allNonFlIxs = [
+    ...cuRequestIxs,
+    ...withdrawIxs.instructions,
+    mergeIx,
+    tradeIx,
+    ...depositIxs.instructions
   ];
-  if (result.length > maxBundleTxs) return null;
-  return result;
-}
-function compoundQuoteRisk(firstLeg, secondLeg) {
-  const compound = (a, b) => {
-    if (a == null && b == null) return void 0;
-    const x = Number(a ?? 0);
-    const y = Number(b ?? 0);
-    return String(1 - (1 - x) * (1 - y));
-  };
-  return {
-    slippageBps: Math.round(
-      (1 - (1 - firstLeg.slippageBps / 1e4) * (1 - secondLeg.slippageBps / 1e4)) * 1e4
-    ),
-    priceImpactPct: compound(firstLeg.priceImpactPct, secondLeg.priceImpactPct)
-  };
-}
-function mergeBridgeQuotes(firstLeg, secondLeg) {
-  return {
-    inAmount: firstLeg.inAmount,
-    outAmount: secondLeg.outAmount,
-    otherAmountThreshold: secondLeg.otherAmountThreshold,
-    ...compoundQuoteRisk(firstLeg, secondLeg),
-    provider: firstLeg.provider
-  };
-}
-function mergeBridgeQuotesDebt(firstLeg, secondLeg) {
-  return {
-    inAmount: firstLeg.outAmount,
-    outAmount: secondLeg.inAmount,
-    otherAmountThreshold: secondLeg.inAmount,
-    ...compoundQuoteRisk(firstLeg, secondLeg),
-    provider: firstLeg.provider
-  };
-}
-function mergeBridgeQuotesLoop(firstLeg, secondLeg) {
-  return {
-    inAmount: secondLeg.inAmount,
-    outAmount: firstLeg.outAmount,
-    otherAmountThreshold: firstLeg.otherAmountThreshold,
-    ...compoundQuoteRisk(firstLeg, secondLeg),
-    provider: firstLeg.provider
-  };
-}
-function blockhashOf(leg) {
-  const tx = leg.transactions[0];
-  return tx ? tx.message.recentBlockhash : web3_js.PublicKey.default.toBase58();
-}
-async function composeBridgedSwap(params) {
-  const {
-    firstLeg,
-    buildSecondLeg,
+  const { sizeConstraint } = computeFlashLoanNonSwapBudget({
+    program,
     marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    ixs: allNonFlIxs
+  });
+  compileFlashloanPrecheck({
+    allIxs: allNonFlIxs,
+    payer: authority,
+    luts,
+    sizeConstraint,
+    swapIxCount: 0,
+    swapLutCount: 0
+  });
+  const flashloanTx = await makeFlashLoanTx({
     program,
-    banksMap,
-    assetShareValueMultiplierByBank,
-    feePayer,
-    maxBundleTxs = MAX_BRIDGED_BUNDLE_TXS
-  } = params;
-  if (!firstLeg.quoteResponse) return null;
-  const projectedAccount = projectAccountAfterFirstLeg(
     marginfiAccount,
-    classifyTxs(firstLeg.transactions).flashloans,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs: allNonFlIxs,
+    isSync: false
+  });
+  const txSize = getTxSize(flashloanTx);
+  const totalKeys = getTotalAccountKeys(flashloanTx);
+  if (txSize > MAX_TX_SIZE || totalKeys > MAX_ACCOUNT_LOCKS) {
+    throw TransactionBuildingError.swapSizeExceededPositionSwap(txSize, totalKeys, void 0);
+  }
+  const swapQuote = {
+    inAmount: syExact.toString(),
+    outAmount: exactPtOut.toString(),
+    otherAmountThreshold: minPtOut.toString(),
+    slippageBps
+  };
+  return { flashloanTx, swapQuote, withdrawIxs, depositIxs };
+}
+async function simulateRollReturn({
+  program,
+  marginfiAccount,
+  bankMap,
+  connection,
+  blockhash,
+  luts,
+  ixs,
+  programId,
+  label
+}) {
+  const quoteTx = await makeFlashLoanTx({
     program,
-    banksMap,
-    assetShareValueMultiplierByBank
+    marginfiAccount,
+    bankMap,
+    addressLookupTableAccounts: luts,
+    blockhash,
+    ixs,
+    isSync: false
+  });
+  const sim = await connection.simulateTransaction(quoteTx, {
+    sigVerify: false,
+    replaceRecentBlockhash: true
+  });
+  const logs = sim.value.logs ?? [];
+  if (process.env.ROLL_DEBUG) {
+    console.error(
+      `[roll ${label} sim] err:`,
+      JSON.stringify(sim.value.err),
+      "returnData:",
+      JSON.stringify(sim.value.returnData),
+      "logsLen:",
+      logs.length,
+      "truncated:",
+      logs.some((l) => l.includes("truncated"))
+    );
+  }
+  const prefix = `Program return: ${programId.toBase58()} `;
+  const line = [...logs].reverse().find((l) => l.startsWith(prefix));
+  if (!line) {
+    throw new Error(
+      `roll-pt: could not read ${label} return data from quote simulation (err=${JSON.stringify(
+        sim.value.err
+      )})`
+    );
+  }
+  return Buffer.from(line.slice(prefix.length), "base64");
+}
+function readReturnU64(data, offset, what) {
+  if (data.length < offset + 8) {
+    throw new Error(`roll-pt: ${what} return data too short (${data.length} bytes)`);
+  }
+  return data.readBigUInt64LE(offset);
+}
+async function quoteClmmTradeOut({
+  connection,
+  clmm,
+  amountInSyNative,
+  payer
+}) {
+  const excluded = /* @__PURE__ */ new Set([
+    clmm.tradePtAccounts.tokenSyEscrow.toBase58(),
+    clmm.tradePtAccounts.tokenFeeTreasurySy.toBase58()
+  ]);
+  const largest = await connection.getTokenLargestAccounts(clmm.sy.mint);
+  const funded = largest.value.find(
+    (a) => !excluded.has(a.address.toBase58()) && BigInt(a.amount) >= amountInSyNative
   );
-  const secondLeg = await buildSecondLeg(projectedAccount);
-  if (!secondLeg.quoteResponse) return null;
-  const transactions = composeBundle(
-    firstLeg.transactions,
-    secondLeg.transactions,
-    feePayer,
-    blockhashOf(firstLeg),
-    maxBundleTxs
+  if (!funded) {
+    throw new Error(
+      "roll-pt: no SY holder large enough to quote the buy \u2014 the roll size exceeds available CLMM liquidity for this pair"
+    );
+  }
+  const parsed = await connection.getParsedAccountInfo(funded.address);
+  const info = parsed.value?.data?.parsed?.info;
+  if (!info?.owner) throw new Error("roll-pt: could not resolve the quote SY holder's owner");
+  const trader = new web3_js.PublicKey(info.owner);
+  const ptTokenProgram = clmm.pt.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const tokenPtTrader = getAssociatedTokenAddressSync(clmm.pt.mint, trader, true, ptTokenProgram);
+  const quoteIx = makeExponentClmmTradePtIx(
+    { ...clmm.tradePtAccounts, trader, tokenSyTrader: funded.address, tokenPtTrader },
+    exponentClmmBuyPtArgs({ amountInSyNative, minPtOutNative: 1n })
   );
-  if (!transactions) return null;
-  return { transactions, firstLegQuote: firstLeg.quoteResponse, secondLegQuote: secondLeg.quoteResponse };
+  const createPtAta = createAssociatedTokenAccountIdempotentInstruction(
+    payer,
+    tokenPtTrader,
+    trader,
+    clmm.pt.mint,
+    ptTokenProgram
+  );
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const message = new web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions: [createPtAta, quoteIx]
+  }).compileToV0Message([clmm.addressLookupTable]);
+  const sim = await connection.simulateTransaction(new web3_js.VersionedTransaction(message), {
+    sigVerify: false,
+    replaceRecentBlockhash: true
+  });
+  const rd = sim.value.returnData;
+  if (process.env.ROLL_DEBUG) {
+    console.error("[roll trade quote] err:", JSON.stringify(sim.value.err), "returnData?", !!rd);
+  }
+  if (!rd?.data || rd.programId !== EXPONENT_CLMM_PROGRAM_ID.toBase58()) {
+    throw new Error(
+      `roll-pt: CLMM trade quote produced no return data (err=${JSON.stringify(sim.value.err)})`
+    );
+  }
+  const data = Buffer.from(rd.data[0], rd.data[1]);
+  return readReturnU64(data, TRADE_PT_EVENT_AMOUNT_OUT_OFFSET, "trade_pt amount_out");
 }
 var MAX_BALANCES = 16;
 var DEFAULT_MAX_TRANSFER_POSITIONS = 5;
@@ -71350,30 +71714,99 @@ function patchDepositAmount(ix, amountNative) {
 }
 
 // src/services/account/utils/bridge.utils.ts
-function accountConflictsWithBridge(account, bankPk, side) {
-  const balance = account.balances.find((b) => b.active && b.bankPk.equals(bankPk));
+function accountConflictsWithBridgeBank(marginfiAccount, bridgeBankPk, bridgeTokenSide) {
+  const balance = marginfiAccount.balances.find((b) => b.active && b.bankPk.equals(bridgeBankPk));
   if (!balance) return false;
-  return side === "deposit" ? balance.liabilityShares.gt(0) : balance.assetShares.gt(0);
+  return bridgeTokenSide === "deposit" ? balance.liabilityShares.gt(0) : balance.assetShares.gt(0);
 }
-function resolveBridgeBanks(params) {
-  const { orderedBridgeMints, banks, marginfiAccount, side } = params;
-  const passesSideFilter = side === "borrow" ? isStandardBorrowable : isStandardDepositable;
-  const bridges = [];
-  const conflicts = [];
+function resolveBridgeCandidateBanks(params) {
+  const { prioritizedBridgeCandidateMints, groupBanks, marginfiAccount, bridgeTokenSide } = params;
+  const passesSideFilter = bridgeTokenSide === "borrow" ? isStandardBorrowable : isStandardDepositable;
+  const usableBridgeBanks = [];
+  const conflictingBridgeBanks = [];
   const seenMints = /* @__PURE__ */ new Set();
-  for (const mint of orderedBridgeMints) {
+  for (const mint of prioritizedBridgeCandidateMints) {
     const mintKey = mint.toBase58();
     if (seenMints.has(mintKey)) continue;
     seenMints.add(mintKey);
-    const bank = banks.find((b) => b.mint.equals(mint) && passesSideFilter(b));
+    const bank = groupBanks.find((b) => b.mint.equals(mint) && passesSideFilter(b));
     if (!bank) continue;
-    if (accountConflictsWithBridge(marginfiAccount, bank.address, side)) {
-      conflicts.push(bank);
+    if (accountConflictsWithBridgeBank(marginfiAccount, bank.address, bridgeTokenSide)) {
+      conflictingBridgeBanks.push(bank);
     } else {
-      bridges.push(bank);
+      usableBridgeBanks.push(bank);
+    }
+  }
+  return { usableBridgeBanks, conflictingBridgeBanks };
+}
+
+// src/services/account/utils/bridge-routing.utils.ts
+var DEFAULT_BRIDGE_MINTS = [USDC_MINT, WSOL_MINT, USDT_MINT];
+async function resolveTokenProgramForMint(mint, connection, tokenProgramCacheByMint) {
+  const mintKey = mint.toBase58();
+  const cached = tokenProgramCacheByMint.get(mintKey);
+  if (cached) return cached;
+  const owner = (await connection.getAccountInfo(mint))?.owner ?? TOKEN_PROGRAM_ID;
+  tokenProgramCacheByMint.set(mintKey, owner);
+  return owner;
+}
+function selectSwapBridges(args) {
+  const prioritizedCandidateMints = (args.bridgeCandidateMints ?? DEFAULT_BRIDGE_MINTS).filter(
+    (mint) => !mint.equals(args.sourceMint) && !mint.equals(args.destinationMint)
+  );
+  return resolveBridgeCandidateBanks({
+    prioritizedBridgeCandidateMints: prioritizedCandidateMints,
+    groupBanks: [...args.bankMap.values()],
+    marginfiAccount: args.marginfiAccount,
+    bridgeTokenSide: args.bridgeTokenSide
+  });
+}
+function isAbortError(e) {
+  return e instanceof DOMException && e.name === "AbortError";
+}
+async function tryBridgeCandidates(args) {
+  for (const bridgeBank of args.usableBridgeBanks) {
+    if (args.abortSignal?.aborted) {
+      throw new DOMException("Operation was aborted", "AbortError");
+    }
+    try {
+      const result = await args.buildBundleThroughBridge(bridgeBank);
+      if (result) return result;
+    } catch (e) {
+      if (isAbortError(e)) throw e;
+      console.warn(
+        `[bridge-routing] candidate ${bridgeBank.tokenSymbol ?? bridgeBank.mint.toBase58()} failed:`,
+        e instanceof Error ? e.message : e
+      );
     }
   }
-  return { bridges, conflicts };
+  if (args.usableBridgeBanks.length === 0 && args.conflictingBridgeBanks.length > 0) {
+    throw TransactionBuildingError.bridgeConflict(
+      args.conflictingBridgeBanks.map((bank) => ({
+        bankAddress: bank.address.toBase58(),
+        mint: bank.mint.toBase58(),
+        symbol: bank.tokenSymbol
+      })),
+      args.bridgeTokenSide
+    );
+  }
+  return null;
+}
+function sharedBridgeLegContext(params) {
+  return {
+    program: params.program,
+    marginfiAccount: params.marginfiAccount,
+    connection: params.connection,
+    bankMap: params.bankMap,
+    oraclePrices: params.oraclePrices,
+    bankMetadataMap: params.bankMetadataMap,
+    assetShareValueMultiplierByBank: params.assetShareValueMultiplierByBank,
+    swapOpts: params.swapOpts,
+    addressLookupTableAccounts: params.addressLookupTableAccounts,
+    overrideInferAccounts: params.overrideInferAccounts,
+    crossbarUrl: params.crossbarUrl,
+    swapEngineRunner: params.swapEngineRunner
+  };
 }
 
 // src/services/price/utils/smart-crank.utils.ts
@@ -75256,6 +75689,82 @@ var MarginfiAccountWrapper = class {
     };
     return this.account.makeSwapDebtTx(fullParams);
   }
+  /**
+   * Creates a loop (leverage) transaction with a transparent bridged (double-hop) fallback and
+   * auto-injected client data.
+   *
+   * One call: tries the direct {@link makeLoopTx} first; if its borrow→deposit swap can't fit one
+   * transaction or has no route, it loops the deposit asset against a value-equivalent borrow of a
+   * bridge token (USDC/wSOL/USDT by default, override via `bridgeOpts.bridgeCandidateMints`) and
+   * debt-swaps that bridge debt to the requested borrow asset — one atomic Jito bundle.
+   * `result.bridgeMint` is set only when the bridged path was used.
+   *
+   * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+   * addressLookupTables, assetShareValueMultiplierByBank
+   *
+   * @param params - Loop parameters (user provides: connection, depositOpts, borrowOpts, swapOpts, bridgeOpts?, etc.)
+   */
+  async makeBridgedLoopTx(params) {
+    return this.account.makeBridgedLoopTx({
+      ...params,
+      program: this.client.program,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      addressLookupTableAccounts: this.client.addressLookupTables,
+      assetShareValueMultiplierByBank: this.client.assetShareValueMultiplierByBank
+    });
+  }
+  /**
+   * Creates a collateral-swap transaction with a transparent bridged (double-hop) fallback and
+   * auto-injected client data.
+   *
+   * One call: tries the direct {@link makeSwapCollateralTx} first; if the swap `A → C` can't fit
+   * one transaction or has no route, it decomposes into `A → bridge` + `bridge → C` through a
+   * bridge token, composed as one atomic Jito bundle. `result.bridgeMint` is set only when the
+   * bridged path was used.
+   *
+   * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+   * addressLookupTables, assetShareValueMultiplierByBank
+   *
+   * @param params - Swap collateral parameters (user provides: connection, withdrawOpts, depositOpts, swapOpts, bridgeOpts?, etc.)
+   */
+  async makeBridgedSwapCollateralTx(params) {
+    return this.account.makeBridgedSwapCollateralTx({
+      ...params,
+      program: this.client.program,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      addressLookupTableAccounts: this.client.addressLookupTables,
+      assetShareValueMultiplierByBank: this.client.assetShareValueMultiplierByBank
+    });
+  }
+  /**
+   * Creates a debt-swap transaction with a transparent bridged (double-hop) fallback and
+   * auto-injected client data.
+   *
+   * One call: tries the direct {@link makeSwapDebtTx} first; if the swap `A → C` can't fit one
+   * transaction or has no route, the first leg repays A by borrowing a bridge token and the second
+   * leg repays exactly that bridge debt while borrowing C — one atomic Jito bundle.
+   * `result.bridgeMint` is set only when the bridged path was used.
+   *
+   * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap,
+   * addressLookupTables, assetShareValueMultiplierByBank
+   *
+   * @param params - Swap debt parameters (user provides: connection, repayOpts, borrowOpts, swapOpts, bridgeOpts?, etc.)
+   */
+  async makeBridgedSwapDebtTx(params) {
+    return this.account.makeBridgedSwapDebtTx({
+      ...params,
+      program: this.client.program,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      addressLookupTableAccounts: this.client.addressLookupTables,
+      assetShareValueMultiplierByBank: this.client.assetShareValueMultiplierByBank
+    });
+  }
   /**
    * Creates a deposit transaction with auto-injected client data.
    *
@@ -76025,6 +76534,7 @@ exports.Bank = Bank;
 exports.BankConfig = BankConfig;
 exports.BankConfigFlag = BankConfigFlag;
 exports.BankVaultType = BankVaultType;
+exports.DEFAULT_BRIDGE_MINTS = DEFAULT_BRIDGE_MINTS;
 exports.DEFAULT_CROSSBAR_URL = DEFAULT_CROSSBAR_URL;
 exports.DEFAULT_FALLBACK_CROSSBAR_URL = DEFAULT_FALLBACK_CROSSBAR_URL;
 exports.DEFAULT_ORACLE_MAX_AGE = DEFAULT_ORACLE_MAX_AGE;
@@ -76098,9 +76608,10 @@ exports.TransactionConfigMap = TransactionConfigMap;
 exports.TransactionType = TransactionType;
 exports.USDC_DECIMALS = USDC_DECIMALS;
 exports.USDC_MINT = USDC_MINT;
+exports.USDT_MINT = USDT_MINT;
 exports.WSOL_MINT = WSOL_MINT;
 exports.ZERO_ORACLE_KEY = ZERO_ORACLE_KEY;
-exports.accountConflictsWithBridge = accountConflictsWithBridge;
+exports.accountConflictsWithBridgeBank = accountConflictsWithBridgeBank;
 exports.accountFlagToBN = accountFlagToBN;
 exports.addOracleToBanksIx = addOracleToBanksIx;
 exports.addTransactionMetadata = addTransactionMetadata;
@@ -76305,6 +76816,7 @@ exports.hasEmodeEntryFlag = hasEmodeEntryFlag;
 exports.hasEmodeFlag = hasEmodeFlag;
 exports.hasHealthCacheFlag = hasHealthCacheFlag;
 exports.healthCacheToDto = healthCacheToDto;
+exports.isBridgeConflictError = isBridgeConflictError;
 exports.isDecomposableSwapError = isDecomposableSwapError;
 exports.isDepositIx = isDepositIx;
 exports.isFlashloan = isFlashloan;
@@ -76319,6 +76831,9 @@ exports.makeAddPermissionlessStakedBankIx = makeAddPermissionlessStakedBankIx;
 exports.makeBeginFlashLoanIx = makeBeginFlashLoanIx3;
 exports.makeBorrowIx = makeBorrowIx3;
 exports.makeBorrowTx = makeBorrowTx;
+exports.makeBridgedLoopTx = makeBridgedLoopTx;
+exports.makeBridgedSwapCollateralTx = makeBridgedSwapCollateralTx;
+exports.makeBridgedSwapDebtTx = makeBridgedSwapDebtTx;
 exports.makeBulkRepayTx = makeBulkRepayTx;
 exports.makeBulkWithdrawTx = makeBulkWithdrawTx;
 exports.makeBundleTipIx = makeBundleTipIx;
@@ -76406,10 +76921,12 @@ exports.patchDepositAmount = patchDepositAmount;
 exports.requireBank = requireBank;
 exports.requireTokenProgram = requireTokenProgram;
 exports.resolveAmount = resolveAmount;
-exports.resolveBridgeBanks = resolveBridgeBanks;
+exports.resolveBridgeCandidateBanks = resolveBridgeCandidateBanks;
+exports.resolveTokenProgramForMint = resolveTokenProgramForMint;
 exports.runSwapEngine = runSwapEngine;
 exports.selectLutsForAccountAction = selectLutsForAccountAction;
 exports.selectLutsForBanks = selectLutsForBanks;
+exports.selectSwapBridges = selectSwapBridges;
 exports.serializeBankConfigOpt = serializeBankConfigOpt;
 exports.serializeInstruction = serializeInstruction;
 exports.serializeInterestRateConfig = serializeInterestRateConfig;
@@ -76420,6 +76937,7 @@ exports.serializeOracleSetupToIndex = serializeOracleSetupToIndex;
 exports.serializeRiskTier = serializeRiskTier;
 exports.serializeSwapEngineRequest = serializeSwapEngineRequest;
 exports.serializeSwapEngineResult = serializeSwapEngineResult;
+exports.sharedBridgeLegContext = sharedBridgeLegContext;
 exports.shortenAddress = shortenAddress;
 exports.simulateAccountHealthCache = simulateAccountHealthCache;
 exports.simulateAccountHealthCacheWithFallback = simulateAccountHealthCacheWithFallback;
@@ -76435,6 +76953,7 @@ exports.toEmodeSettingsDto = toEmodeSettingsDto;
 exports.toInterestRateConfigDto = toInterestRateConfigDto;
 exports.toJupiterConfig = toJupiterConfig;
 exports.toNumber = toNumber;
+exports.tryBridgeCandidates = tryBridgeCandidates;
 exports.uiToNative = uiToNative;
 exports.uiToNativeBigNumber = uiToNativeBigNumber;
 exports.validatorStakeGroupToDto = validatorStakeGroupToDto;