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

package/dist/index.js

@@ -103,6 +103,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 {
@@ -233,6 +234,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
    */
@@ -249,6 +263,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");
@@ -408,6 +425,7 @@ var PRIORITY_TX_SIZE = 44;
 var WSOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
 var LST_MINT = new PublicKey("LSTxxxnJzKDFSLr4dUkPcmCf5VyryEqzPLz5j4bpxFp");
 var USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var USDT_MINT = new PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB");
 var USDC_DECIMALS = 6;
 
 // src/utils/accounting.utils.ts
@@ -67209,1775 +67227,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(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 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 TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new 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(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 = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  const swapNeeded = !depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint);
-  const destinationTokenAccount = getAssociatedTokenAddressSync(
-    new 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(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(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 TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new 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 = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
-  ];
-  let amountToDeposit;
-  let swapInstructions = [];
-  let setupInstructions = [];
-  let swapLookupTables = [];
-  let swapQuote;
-  let sizeConstraintUsed = 0;
-  let withdrawIxs;
-  switch (withdrawOpts.withdrawBank.config.assetTag) {
-    case 3 /* KAMINO */: {
-      const reserve = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
-      if (!reserve) {
-        throw TransactionBuildingError.kaminoReserveNotFound(
-          withdrawOpts.withdrawBank.address.toBase58(),
-          withdrawOpts.withdrawBank.mint.toBase58(),
-          withdrawOpts.withdrawBank.tokenSymbol
-        );
-      }
-      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
-      const adjustedAmount = new BigNumber(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(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 TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new 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 = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    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 TransactionMessage({
-      payerKey: marginfiAccount.authority,
-      recentBlockhash: blockhash,
-      instructions: updateFeedIxs
-    }).compileToV0Message(feedLuts);
-    additionalTxs.push(
-      addTransactionMetadata(new 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 = [
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
-    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(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 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 TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: blockhash,
-    instructions: [createPtAta, quoteIx]
-  }).compileToV0Message([clmm.addressLookupTable]);
-  const sim = await connection.simulateTransaction(new 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).
@@ -69382,6 +67923,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.
    *
@@ -69421,425 +68042,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 : 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(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 TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new 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 = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    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(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 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 TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new 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(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 = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  const swapNeeded = !depositOpts.depositBank.mint.equals(borrowOpts.borrowBank.mint);
+  const destinationTokenAccount = getAssociatedTokenAddressSync(
+    new 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(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) return null;
+  const tokenProgramCache = new Map(bridgeOpts?.tokenProgramByMint);
+  return tryBridgeCandidates({
+    usableBridgeBanks,
+    conflictingBridgeBanks,
+    bridgeTokenSide: "borrow",
+    abortSignal: bridgeOpts?.abortSignal,
+    buildBundleThroughBridge: async (bridgeBank) => {
+      const birdgeBankPrice = oraclePriceOf(bridgeBank);
+      if (birdgeBankPrice <= 0) return null;
+      const bridgeBorrowUi = params.borrowOpts.borrowAmount * borrowBankPrice / birdgeBankPrice;
+      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: birdgeBankPrice
         }
+      });
+      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: birdgeBankPrice
+          },
+          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(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 TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new 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 = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  let amountToDeposit;
+  let swapInstructions = [];
+  let setupInstructions = [];
+  let swapLookupTables = [];
+  let swapQuote;
+  let sizeConstraintUsed = 0;
+  let withdrawIxs;
+  switch (withdrawOpts.withdrawBank.config.assetTag) {
+    case 3 /* KAMINO */: {
+      const reserve = bankMetadataMap[withdrawOpts.withdrawBank.address.toBase58()]?.kaminoStates?.reserveState;
+      if (!reserve) {
+        throw TransactionBuildingError.kaminoReserveNotFound(
+          withdrawOpts.withdrawBank.address.toBase58(),
+          withdrawOpts.withdrawBank.mint.toBase58(),
+          withdrawOpts.withdrawBank.tokenSymbol
+        );
+      }
+      const multiplier = assetShareValueMultiplierByBank.get(withdrawOpts.withdrawBank.address.toBase58()) ?? new BigNumber(1);
+      const adjustedAmount = new BigNumber(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 TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new 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 = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    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(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 : 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 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 TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions: [createPtAta, quoteIx]
+  }).compileToV0Message([clmm.addressLookupTable]);
+  const sim = await connection.simulateTransaction(new 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;
@@ -71322,30 +71686,95 @@ 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;
     }
   }
-  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
@@ -75228,6 +75657,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.
    *
@@ -75985,6 +76490,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridge, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isDecomposableSwapError, isDepositIx, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSmartCrankSwbFeedIxForAccounts, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveAmount, resolveBridgeBanks, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
+export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_BRIDGE_MINTS, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, USDC_DECIMALS, USDC_MINT, USDT_MINT, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSmartCrankSwbFeedIxForAccounts, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveAmount, resolveBridgeCandidateBanks, resolveTokenProgramForMint, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map