@0dotxyz/p0-ts-sdk 1.1.1 → 1.2.0-alpha.2

package/dist/index.cjs

@@ -33284,7 +33284,8 @@ async function makeSetupIx({ connection, authority, tokens }) {
       }
     }
     return ixs;
-  } catch {
+  } catch (error) {
+    console.error("[makeSetupIx] Failed to create setup instructions:", error);
     return [];
   }
 }
@@ -43237,104 +43238,729 @@ async function makeWithdrawEmissionsIx(program, marginfiAccount, banks, mintData
   ixs.push(withdrawEmissionsIx);
   return { instructions: ixs, keys: [] };
 }
-
-// src/services/account/services/account-simulation.service.ts
-async function simulateAccountHealthCacheWithFallback(props) {
-  let marginfiAccount = props.marginfiAccount;
-  const activeBalances = props.balances.filter((b) => b.active);
-  const { assets: assetValueEquity, liabilities: liabilityValueEquity } = computeHealthComponentsWithoutBiasLegacy(
-    activeBalances,
-    props.bankMap,
-    props.oraclePrices,
-    2 /* Equity */
+async function makeSwapCollateralTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    withdrawOpts,
+    depositOpts,
+    bankMetadataMap,
+    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 updateDriftMarketIxs = makeUpdateDriftMarketIxs(
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address],
+    bankMetadataMap
   );
-  try {
-    const simulatedAccount = await simulateAccountHealthCache({
-      program: props.program,
-      bankMap: props.bankMap,
-      marginfiAccountPk: props.marginfiAccount.address,
-      balances: props.balances,
-      bankMetadataMap: props.bankMetadataMap
+  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [withdrawOpts.withdrawBank.address, depositOpts.depositBank.address],
+    bankMetadataMap
+  );
+  const { flashloanTx, setupInstructions, swapQuote, withdrawIxs, depositIxs } = await buildSwapCollateralFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(withdrawOpts.withdrawBank.mint) || mintKey?.equals(depositOpts.depositBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    instructions: [...withdrawIxs.instructions, ...depositIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0) {
+    const ixs = [
+      ...setupIxs,
+      ...kaminoRefreshIxs.instructions,
+      ...updateDriftMarketIxs.instructions
+    ];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
     });
-    simulatedAccount.healthCache.assetValueEquity = bigNumberToWrappedI80F48(assetValueEquity);
-    simulatedAccount.healthCache.liabilityValueEquity = bigNumberToWrappedI80F48(liabilityValueEquity);
-    marginfiAccount = parseMarginfiAccountRaw(props.marginfiAccount.address, simulatedAccount);
-  } catch (e) {
-    console.log("e", e);
-    const { assets: assetValueMaint, liabilities: liabilityValueMaint } = computeHealthComponentsLegacy(
-      activeBalances,
-      props.bankMap,
-      props.oraclePrices,
-      1 /* Maintenance */,
-      []
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
     );
-    const { assets: assetValueInitial, liabilities: liabilityValueInitial } = computeHealthComponentsLegacy(
-      activeBalances,
-      props.bankMap,
-      props.oraclePrices,
-      0 /* Initial */,
-      []
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
     );
-    marginfiAccount.healthCache = {
-      assetValue: assetValueInitial,
-      liabilityValue: liabilityValueInitial,
-      assetValueMaint,
-      liabilityValueMaint,
-      assetValueEquity,
-      liabilityValueEquity,
-      timestamp: new BigNumber10__default.default(0),
-      flags: [],
-      prices: [],
-      simulationStatus: 2 /* COMPUTED */
-    };
-    if (e instanceof HealthCacheSimulationError) {
-      return { marginfiAccount, error: e };
-    }
   }
-  return { marginfiAccount };
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
 }
-async function simulateAccountHealthCache(props) {
-  const { program, bankMap, marginfiAccountPk, balances, bankMetadataMap } = props;
-  const activeBalances = balances.filter((b) => b.active);
-  const activeBanks = activeBalances.map((balance) => bankMap.get(balance.bankPk.toBase58())).filter((bank) => !!bank);
-  const kaminoBanks = activeBanks.filter((bank) => bank.config.assetTag === 3 /* KAMINO */);
-  const driftBanks = activeBanks.filter((bank) => bank.config.assetTag === 4 /* DRIFT */);
-  const staleSwbOracles = activeBanks.filter(
-    (bank) => bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "SwitchboardV2" /* SwitchboardV2 */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */ || bank.config.oracleSetup === "DriftSwitchboardPull" /* DriftSwitchboardPull */ || bank.config.oracleSetup === "SolendSwitchboardPull" /* SolendSwitchboardPull */
-  ).filter((bank) => !bank.oracleKey.equals(new web3_js.PublicKey(ZERO_ORACLE_KEY)));
-  const computeIx = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-    units: 14e5
-  });
-  const blockhash = (await program.provider.connection.getLatestBlockhash("confirmed")).blockhash;
-  const fundAccountIx = web3_js.SystemProgram.transfer({
-    fromPubkey: new web3_js.PublicKey("DD3AeAssFvjqTvRTrRAtpfjkBF8FpVKnFuwnMLN9haXD"),
-    // marginfi SOL VAULT
-    toPubkey: program.provider.publicKey,
-    lamports: 1e8
-    // 0.1 SOL
-  });
-  const updateDriftMarketData = driftBanks.map((bank) => {
-    const bankMetadata = bankMetadataMap?.[bank.address.toBase58()];
-    if (!bankMetadata?.driftStates) {
-      console.error(`Bank metadata for drift bank ${bank.address.toBase58()} not found`);
-      return;
+async function buildSwapCollateralFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  withdrawOpts,
+  depositOpts,
+  swapOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  overrideInferAccounts,
+  blockhash
+}) {
+  const { withdrawBank, tokenProgram: withdrawTokenProgram, totalPositionAmount } = withdrawOpts;
+  const { depositBank, tokenProgram: depositTokenProgram } = depositOpts;
+  const swapResult = [];
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  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 adjustedAmount = new BigNumber10.BigNumber(totalPositionAmount).div(withdrawOpts.withdrawBank.assetShareValue).times(1.0001).toNumber();
+      withdrawIxs = await makeKaminoWithdrawIx3({
+        program,
+        bank: withdrawBank,
+        bankMap,
+        tokenProgram: withdrawTokenProgram,
+        amount: adjustedAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        reserve,
+        withdrawAll: true,
+        isSync: true,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
     }
-    const driftMarket = bankMetadata.driftStates.spotMarketState;
-    return driftMarket;
-  }).filter((state) => !!state);
-  const refreshReserveData = kaminoBanks.map((bank) => {
-    const bankMetadata = bankMetadataMap?.[bank.address.toBase58()];
-    if (!bankMetadata?.kaminoStates) {
-      console.error(`Bank metadata for kamino bank ${bank.address.toBase58()} not found`);
-      return;
+    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: totalPositionAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        driftSpotMarket: driftState.spotMarketState,
+        userRewards: driftState.userRewards,
+        withdrawAll: true,
+        isSync: false,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
     }
-    if (!bankMetadata?.kaminoStates || !bank.kaminoIntegrationAccounts) {
-      console.error(`Integration data for kamino bank ${bank.address.toBase58()} not found`);
-      return;
+    default: {
+      withdrawIxs = await makeWithdrawIx3({
+        program,
+        bank: withdrawBank,
+        bankMap,
+        tokenProgram: withdrawTokenProgram,
+        amount: totalPositionAmount,
+        marginfiAccount,
+        authority: marginfiAccount.authority,
+        withdrawAll: true,
+        isSync: true,
+        opts: {
+          createAtas: false,
+          wrapAndUnwrapSol: false,
+          overrideInferAccounts
+        }
+      });
+      break;
     }
-    const kaminoReserve = bank.kaminoIntegrationAccounts.kaminoReserve;
-    const lendingMarket = bankMetadata.kaminoStates.reserveState.lendingMarket;
-    return {
+  }
+  if (depositBank.mint.equals(withdrawBank.mint)) {
+    swapResult.push({
+      amountToDeposit: totalPositionAmount,
+      swapInstructions: [],
+      setupInstructions: [],
+      swapLookupTables: []
+    });
+  } else {
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      depositBank.mint,
+      marginfiAccount.authority,
+      true,
+      depositTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+    );
+    const swapResponses = await getJupiterSwapIxsForFlashloan({
+      quoteParams: {
+        inputMint: withdrawBank.mint.toBase58(),
+        outputMint: depositBank.mint.toBase58(),
+        amount: uiToNative(totalPositionAmount, withdrawBank.mintDecimals).toNumber(),
+        dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
+        slippageBps: swapOpts.jupiterOptions?.slippageBps,
+        swapMode: "ExactIn",
+        platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps,
+        onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
+      },
+      authority: marginfiAccount.authority,
+      connection,
+      destinationTokenAccount,
+      configParams: swapOpts.jupiterOptions?.configParams
+    });
+    swapResponses.forEach((response) => {
+      const outAmountThreshold = nativeToUi(
+        response.quoteResponse.otherAmountThreshold,
+        depositBank.mintDecimals
+      );
+      swapResult.push({
+        amountToDeposit: outAmountThreshold,
+        swapInstructions: [response.swapInstruction],
+        setupInstructions: response.setupInstructions,
+        swapLookupTables: response.addressLookupTableAddresses,
+        quoteResponse: response.quoteResponse
+      });
+    });
+  }
+  if (swapResult.length === 0) {
+    throw new Error(
+      `No swap routes found for ${withdrawBank.mint.toBase58()} -> ${depositBank.mint.toBase58()}`
+    );
+  }
+  for (const [index, item] of swapResult.entries()) {
+    const {
+      amountToDeposit,
+      swapInstructions,
+      setupInstructions,
+      swapLookupTables,
+      quoteResponse
+    } = item;
+    let depositIxs;
+    switch (depositBank.config.assetTag) {
+      case 3 /* KAMINO */: {
+        const reserve = bankMetadataMap[depositBank.address.toBase58()]?.kaminoStates?.reserveState;
+        if (!reserve) {
+          throw TransactionBuildingError.kaminoReserveNotFound(
+            depositBank.address.toBase58(),
+            depositBank.mint.toBase58(),
+            depositBank.tokenSymbol
+          );
+        }
+        depositIxs = await makeKaminoDepositIx3({
+          program,
+          bank: depositBank,
+          tokenProgram: depositTokenProgram,
+          amount: amountToDeposit,
+          accountAddress: marginfiAccount.address,
+          authority: marginfiAccount.authority,
+          group: marginfiAccount.group,
+          reserve,
+          opts: {
+            wrapAndUnwrapSol: false,
+            overrideInferAccounts
+          }
+        });
+        break;
+      }
+      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;
+      }
+      default: {
+        depositIxs = await makeDepositIx3({
+          program,
+          bank: depositBank,
+          tokenProgram: depositTokenProgram,
+          amount: amountToDeposit,
+          accountAddress: marginfiAccount.address,
+          authority: marginfiAccount.authority,
+          group: marginfiAccount.group,
+          opts: {
+            wrapAndUnwrapSol: false,
+            overrideInferAccounts
+          }
+        });
+        break;
+      }
+    }
+    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+    const flashloanParams = {
+      program,
+      marginfiAccount,
+      bankMap,
+      addressLookupTableAccounts: luts,
+      blockhash
+    };
+    const flashloanTx = await makeFlashLoanTx({
+      ...flashloanParams,
+      ixs: [
+        ...cuRequestIxs,
+        ...withdrawIxs.instructions,
+        ...swapInstructions,
+        ...depositIxs.instructions
+      ],
+      isSync: true
+    });
+    const txSize = getTxSize(flashloanTx);
+    const keySize = getAccountKeys(flashloanTx, luts);
+    const isLast = index === swapResult.length - 1;
+    if (txSize > MAX_TX_SIZE || keySize > 64) {
+      if (isLast) {
+        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
+      } else {
+        continue;
+      }
+    } else {
+      return {
+        flashloanTx,
+        setupInstructions,
+        swapQuote: quoteResponse,
+        withdrawIxs,
+        depositIxs
+      };
+    }
+  }
+  throw new Error("Failed to build swap collateral flashloan tx");
+}
+async function makeSwapDebtTx(params) {
+  const {
+    program,
+    marginfiAccount,
+    connection,
+    bankMap,
+    oraclePrices,
+    repayOpts,
+    borrowOpts,
+    bankMetadataMap,
+    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 updateDriftMarketIxs = makeUpdateDriftMarketIxs(
+    marginfiAccount,
+    bankMap,
+    [],
+    // debt can be in a drift bank
+    bankMetadataMap
+  );
+  const kaminoRefreshIxs = makeRefreshKaminoBanksIxs(
+    marginfiAccount,
+    bankMap,
+    [repayOpts.repayBank.address, borrowOpts.borrowBank.address],
+    bankMetadataMap
+  );
+  const { flashloanTx, setupInstructions, swapQuote, borrowIxs, repayIxs } = await buildSwapDebtFlashloanTx({
+    ...params,
+    blockhash
+  });
+  const jupiterSetupInstructions = setupInstructions.filter((ix) => {
+    if (ix.programId.equals(web3_js.ComputeBudgetProgram.programId)) {
+      return false;
+    }
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = ix.keys[3]?.pubkey;
+      if (mintKey?.equals(repayOpts.repayBank.mint) || mintKey?.equals(borrowOpts.borrowBank.mint)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  setupIxs.push(...jupiterSetupInstructions);
+  const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    instructions: [...borrowIxs.instructions, ...repayIxs.instructions],
+    program,
+    connection,
+    crossbarUrl
+  });
+  let additionalTxs = [];
+  if (setupIxs.length > 0 || kaminoRefreshIxs.instructions.length > 0 || updateDriftMarketIxs.instructions.length > 0) {
+    const ixs = [
+      ...additionalIxs,
+      ...setupIxs,
+      ...kaminoRefreshIxs.instructions,
+      ...updateDriftMarketIxs.instructions
+    ];
+    const txs = splitInstructionsToFitTransactions([], ixs, {
+      blockhash,
+      payerKey: marginfiAccount.authority,
+      luts: addressLookupTableAccounts ?? []
+    });
+    additionalTxs.push(
+      ...txs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: addressLookupTableAccounts
+        })
+      )
+    );
+  }
+  if (updateFeedIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: marginfiAccount.authority,
+      recentBlockhash: blockhash,
+      instructions: updateFeedIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  const transactions = [...additionalTxs, flashloanTx];
+  return {
+    transactions,
+    actionTxIndex: transactions.length - 1,
+    quoteResponse: swapQuote
+  };
+}
+async function buildSwapDebtFlashloanTx({
+  program,
+  marginfiAccount,
+  bankMap,
+  repayOpts,
+  borrowOpts,
+  swapOpts,
+  bankMetadataMap,
+  addressLookupTableAccounts,
+  connection,
+  overrideInferAccounts,
+  blockhash
+}) {
+  const { repayBank, tokenProgram: repayTokenProgram, totalPositionAmount } = repayOpts;
+  const { borrowBank, tokenProgram: borrowTokenProgram } = borrowOpts;
+  const swapResult = [];
+  const cuRequestIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 12e5 }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
+  ];
+  if (borrowBank.mint.equals(repayBank.mint)) {
+    swapResult.push({
+      amountToRepay: totalPositionAmount,
+      borrowAmount: totalPositionAmount,
+      swapInstructions: [],
+      setupInstructions: [],
+      swapLookupTables: []
+    });
+  } else {
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      repayBank.mint,
+      marginfiAccount.authority,
+      true,
+      repayTokenProgram.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : void 0
+    );
+    const swapResponses = await getJupiterSwapIxsForFlashloan({
+      quoteParams: {
+        inputMint: borrowBank.mint.toBase58(),
+        outputMint: repayBank.mint.toBase58(),
+        amount: uiToNative(totalPositionAmount, repayBank.mintDecimals).toNumber(),
+        dynamicSlippage: swapOpts.jupiterOptions ? swapOpts.jupiterOptions.slippageMode === "DYNAMIC" : true,
+        slippageBps: swapOpts.jupiterOptions?.slippageBps,
+        swapMode: "ExactOut",
+        platformFeeBps: swapOpts.jupiterOptions?.platformFeeBps,
+        onlyDirectRoutes: swapOpts.jupiterOptions?.directRoutesOnly ?? false
+      },
+      authority: marginfiAccount.authority,
+      connection,
+      destinationTokenAccount,
+      configParams: swapOpts.jupiterOptions?.configParams
+    });
+    swapResponses.forEach((response) => {
+      const borrowAmount = nativeToUi(response.quoteResponse.inAmount, borrowBank.mintDecimals);
+      swapResult.push({
+        amountToRepay: totalPositionAmount,
+        borrowAmount,
+        swapInstructions: [response.swapInstruction],
+        setupInstructions: response.setupInstructions,
+        swapLookupTables: response.addressLookupTableAddresses,
+        quoteResponse: response.quoteResponse
+      });
+    });
+  }
+  if (swapResult.length === 0) {
+    throw new Error(
+      `No swap routes found for ${borrowBank.mint.toBase58()} -> ${repayBank.mint.toBase58()}`
+    );
+  }
+  for (const [index, item] of swapResult.entries()) {
+    const {
+      amountToRepay,
+      borrowAmount,
+      swapInstructions,
+      setupInstructions,
+      swapLookupTables,
+      quoteResponse
+    } = item;
+    const borrowIxs = await makeBorrowIx3({
+      program,
+      bank: borrowBank,
+      bankMap,
+      tokenProgram: borrowTokenProgram,
+      amount: borrowAmount,
+      marginfiAccount,
+      authority: marginfiAccount.authority,
+      isSync: true,
+      opts: {
+        createAtas: false,
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts
+      }
+    });
+    const repayIxs = await makeRepayIx3({
+      program,
+      bank: repayBank,
+      tokenProgram: repayTokenProgram,
+      amount: amountToRepay,
+      accountAddress: marginfiAccount.address,
+      authority: marginfiAccount.authority,
+      repayAll: isWholePosition(
+        {
+          amount: totalPositionAmount,
+          isLending: false
+        },
+        amountToRepay,
+        repayBank.mintDecimals
+      ),
+      isSync: true,
+      opts: {
+        wrapAndUnwrapSol: false,
+        overrideInferAccounts
+      }
+    });
+    const luts = [...addressLookupTableAccounts ?? [], ...swapLookupTables];
+    const flashloanParams = {
+      program,
+      marginfiAccount,
+      bankMap,
+      addressLookupTableAccounts: luts,
+      blockhash
+    };
+    const flashloanTx = await makeFlashLoanTx({
+      ...flashloanParams,
+      ixs: [
+        ...cuRequestIxs,
+        ...borrowIxs.instructions,
+        ...swapInstructions,
+        ...repayIxs.instructions
+      ],
+      isSync: true
+    });
+    const txSize = getTxSize(flashloanTx);
+    const keySize = getAccountKeys(flashloanTx, luts);
+    const isLast = index === swapResult.length - 1;
+    if (txSize > MAX_TX_SIZE || keySize > 64) {
+      if (isLast) {
+        throw TransactionBuildingError.jupiterSwapSizeExceededLoop(txSize, keySize);
+      } else {
+        continue;
+      }
+    } else {
+      return {
+        flashloanTx,
+        setupInstructions,
+        swapQuote: quoteResponse,
+        borrowIxs,
+        repayIxs
+      };
+    }
+  }
+  throw new Error("Failed to build swap debt flashloan tx");
+}
+
+// src/services/account/services/account-simulation.service.ts
+async function simulateAccountHealthCacheWithFallback(props) {
+  let marginfiAccount = props.marginfiAccount;
+  const activeBalances = marginfiAccount.balances.filter((b) => b.active);
+  const { assets: assetValueEquity, liabilities: liabilityValueEquity } = computeHealthComponentsWithoutBiasLegacy(
+    activeBalances,
+    props.bankMap,
+    props.oraclePrices,
+    2 /* Equity */
+  );
+  try {
+    const simulatedAccount = await simulateAccountHealthCache({
+      program: props.program,
+      bankMap: props.bankMap,
+      marginfiAccount: props.marginfiAccount,
+      bankMetadataMap: props.bankMetadataMap
+    });
+    simulatedAccount.healthCache.assetValueEquity = bigNumberToWrappedI80F48(assetValueEquity);
+    simulatedAccount.healthCache.liabilityValueEquity = bigNumberToWrappedI80F48(liabilityValueEquity);
+    marginfiAccount = parseMarginfiAccountRaw(props.marginfiAccount.address, simulatedAccount);
+  } catch (e) {
+    console.log("e", e);
+    const { assets: assetValueMaint, liabilities: liabilityValueMaint } = computeHealthComponentsLegacy(
+      activeBalances,
+      props.bankMap,
+      props.oraclePrices,
+      1 /* Maintenance */,
+      []
+    );
+    const { assets: assetValueInitial, liabilities: liabilityValueInitial } = computeHealthComponentsLegacy(
+      activeBalances,
+      props.bankMap,
+      props.oraclePrices,
+      0 /* Initial */,
+      []
+    );
+    marginfiAccount.healthCache = {
+      assetValue: assetValueInitial,
+      liabilityValue: liabilityValueInitial,
+      assetValueMaint,
+      liabilityValueMaint,
+      assetValueEquity,
+      liabilityValueEquity,
+      timestamp: new BigNumber10__default.default(0),
+      flags: [],
+      prices: [],
+      simulationStatus: 2 /* COMPUTED */
+    };
+    if (e instanceof HealthCacheSimulationError) {
+      return { marginfiAccount, error: e };
+    }
+  }
+  return { marginfiAccount };
+}
+async function simulateAccountHealthCache(props) {
+  const { program, bankMap, marginfiAccount, bankMetadataMap } = props;
+  const activeBalances = marginfiAccount.balances.filter((b) => b.active);
+  const activeBanks = activeBalances.map((balance) => bankMap.get(balance.bankPk.toBase58())).filter((bank) => !!bank);
+  const kaminoBanks = activeBanks.filter((bank) => bank.config.assetTag === 3 /* KAMINO */);
+  const driftBanks = activeBanks.filter((bank) => bank.config.assetTag === 4 /* DRIFT */);
+  const staleSwbOracles = activeBanks.filter(
+    (bank) => bank.config.oracleSetup === "SwitchboardPull" /* SwitchboardPull */ || bank.config.oracleSetup === "SwitchboardV2" /* SwitchboardV2 */ || bank.config.oracleSetup === "KaminoSwitchboardPull" /* KaminoSwitchboardPull */ || bank.config.oracleSetup === "DriftSwitchboardPull" /* DriftSwitchboardPull */ || bank.config.oracleSetup === "SolendSwitchboardPull" /* SolendSwitchboardPull */
+  ).filter((bank) => !bank.oracleKey.equals(new web3_js.PublicKey(ZERO_ORACLE_KEY)));
+  const computeIx = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+    units: 14e5
+  });
+  const blockhash = (await program.provider.connection.getLatestBlockhash("confirmed")).blockhash;
+  const fundAccountIx = web3_js.SystemProgram.transfer({
+    fromPubkey: new web3_js.PublicKey("DD3AeAssFvjqTvRTrRAtpfjkBF8FpVKnFuwnMLN9haXD"),
+    // marginfi SOL VAULT
+    toPubkey: marginfiAccount.authority,
+    lamports: 1e8
+    // 0.1 SOL
+  });
+  const updateDriftMarketData = driftBanks.map((bank) => {
+    const bankMetadata = bankMetadataMap?.[bank.address.toBase58()];
+    if (!bankMetadata?.driftStates) {
+      console.error(`Bank metadata for drift bank ${bank.address.toBase58()} not found`);
+      return;
+    }
+    const driftMarket = bankMetadata.driftStates.spotMarketState;
+    return driftMarket;
+  }).filter((state) => !!state);
+  const refreshReserveData = kaminoBanks.map((bank) => {
+    const bankMetadata = bankMetadataMap?.[bank.address.toBase58()];
+    if (!bankMetadata?.kaminoStates) {
+      console.error(`Bank metadata for kamino bank ${bank.address.toBase58()} not found`);
+      return;
+    }
+    if (!bankMetadata?.kaminoStates || !bank.kaminoIntegrationAccounts) {
+      console.error(`Integration data for kamino bank ${bank.address.toBase58()} not found`);
+      return;
+    }
+    const kaminoReserve = bank.kaminoIntegrationAccounts.kaminoReserve;
+    const lendingMarket = bankMetadata.kaminoStates.reserveState.lendingMarket;
+    return {
       reserve: kaminoReserve,
       lendingMarket
     };
@@ -43348,7 +43974,7 @@ async function simulateAccountHealthCache(props) {
     swbPullOracles: staleSwbOracles.map((oracle) => ({
       key: oracle.oracleKey
     })),
-    feePayer: program.provider.publicKey,
+    feePayer: marginfiAccount.authority,
     connection: program.provider.connection
   }) : { instructions: [], luts: [] };
   const updateDriftMarketIxs = updateDriftMarketData.map((market) => ({
@@ -43358,16 +43984,16 @@ async function simulateAccountHealthCache(props) {
   }));
   const healthPulseIxs = await makePulseHealthIx2(
     program,
-    marginfiAccountPk,
+    marginfiAccount.address,
     bankMap,
-    balances,
+    marginfiAccount.balances,
     activeBalances.map((b) => b.bankPk),
     []
   );
   const txs = [];
   const additionalTx = new web3_js.VersionedTransaction(
     new web3_js.TransactionMessage({
-      payerKey: program.provider.publicKey,
+      payerKey: marginfiAccount.authority,
       recentBlockhash: blockhash,
       instructions: [
         computeIx,
@@ -43380,7 +44006,7 @@ async function simulateAccountHealthCache(props) {
   txs.push(additionalTx);
   const swbTx = new web3_js.VersionedTransaction(
     new web3_js.TransactionMessage({
-      payerKey: program.provider.publicKey,
+      payerKey: marginfiAccount.authority,
       recentBlockhash: blockhash,
       instructions: [...crankSwbIxs.instructions]
     }).compileToV0Message([...crankSwbIxs.luts])
@@ -43388,7 +44014,7 @@ async function simulateAccountHealthCache(props) {
   txs.push(swbTx);
   const healthTx = new web3_js.VersionedTransaction(
     new web3_js.TransactionMessage({
-      payerKey: program.provider.publicKey,
+      payerKey: marginfiAccount.authority,
       recentBlockhash: blockhash,
       instructions: [computeIx, ...healthPulseIxs.instructions]
     }).compileToV0Message([])
@@ -43399,7 +44025,7 @@ async function simulateAccountHealthCache(props) {
     throw new Error("Too many transactions");
   }
   const simulationResult = await simulateBundle(program.provider.connection.rpcEndpoint, txs, [
-    marginfiAccountPk
+    marginfiAccount.address
   ]);
   const postExecutionAccount = simulationResult.find(
     (result) => result.postExecutionAccounts.length > 0
@@ -43614,23 +44240,19 @@ var fetchMarginfiAccountAddresses = async (program, authority, group) => {
   return marginfiAccounts;
 };
 var fetchMarginfiAccountData = async (program, marginfiAccountPk, bankMap, bankMetadataMap) => {
-  const marginfiAccountRaw = await program.account.marginfiAccount.fetch(marginfiAccountPk, "confirmed");
-  const marginfiAccount = parseMarginfiAccountRaw(
+  const marginfiAccountRaw = await program.account.marginfiAccount.fetch(
     marginfiAccountPk,
-    marginfiAccountRaw
+    "confirmed"
   );
+  const marginfiAccount = parseMarginfiAccountRaw(marginfiAccountPk, marginfiAccountRaw);
   try {
     const simulatedAccount = await simulateAccountHealthCache({
       program,
       bankMap,
-      marginfiAccountPk,
-      balances: marginfiAccount.balances,
+      marginfiAccount,
       bankMetadataMap
     });
-    const marginfiAccountWithCache = parseMarginfiAccountRaw(
-      marginfiAccountPk,
-      simulatedAccount
-    );
+    const marginfiAccountWithCache = parseMarginfiAccountRaw(marginfiAccountPk, simulatedAccount);
     return { marginfiAccount: marginfiAccountWithCache };
   } catch (e) {
     console.error("Error simulating account health cache", e);
@@ -43652,10 +44274,7 @@ async function findRandomAvailableAccountIndex(connection, programId, group, aut
   const BATCH_SIZE = 16;
   const MAX_ATTEMPTS = 8;
   for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-    const indices = randomDistinctIndices(
-      Math.min(BATCH_SIZE, MAX_INDEX),
-      MAX_INDEX
-    );
+    const indices = randomDistinctIndices(Math.min(BATCH_SIZE, MAX_INDEX), MAX_INDEX);
     const pdas = indices.map(
       (i) => deriveMarginfiAccount(programId, group, authority, i, thirdPartyId)[0]
     );
@@ -43843,6 +44462,7 @@ var getJupiterSwapIxsForFlashloan = async ({
       });
     })
   );
+  hasFeeAccount && finalQuoteParams.platformFeeBps && finalQuoteParams.platformFeeBps > 0;
   const swapInstructionResponses = await Promise.all(
     swapQuotes.map(
       (quote) => jupiterApiClient.swapInstructionsPost({
@@ -43867,7 +44487,6 @@ var getJupiterSwapIxsForFlashloan = async ({
   for (let i = 0; i < swapInstructionResponses.length; i++) {
     const response = swapInstructionResponses[i];
     const quote = swapQuotes[i];
-    i === swapInstructionResponses.length - 1;
     if (!response || !quote) continue;
     const address = response.addressLookupTableAddresses;
     const addressesLength = address.length;
@@ -46460,7 +47079,6 @@ var MarginfiAccount = class _MarginfiAccount {
       bankMap,
       oraclePrices,
       marginfiAccount: this,
-      balances: this.balances,
       bankMetadataMap
     });
     return {
@@ -47009,6 +47627,75 @@ var MarginfiAccount = class _MarginfiAccount {
       marginfiAccount: this
     });
   }
+  /**
+   * 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 - Jupiter swap configuration
+   * @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
+    });
+  }
+  /**
+   * 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 - Jupiter swap configuration
+   * @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
+    });
+  }
   /**
    * Creates a deposit transaction.
    *
@@ -47436,6 +48123,50 @@ var MarginfiAccountWrapper = class {
     };
     return this.account.makeRepayWithCollatTx(fullParams);
   }
+  /**
+   * Creates a swap collateral transaction with auto-injected client data.
+   *
+   * Swaps one collateral type for another (e.g., JitoSOL -> mSOL) using a flash loan
+   * so account health is not affected during the swap.
+   *
+   * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap, addressLookupTables
+   *
+   * @param params - Swap collateral parameters (user provides: connection, withdrawOpts, depositOpts, swapOpts, etc.)
+   */
+  async makeSwapCollateralTx(params) {
+    const fullParams = {
+      ...params,
+      program: this.client.program,
+      marginfiAccount: this.account,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      addressLookupTableAccounts: this.client.addressLookupTables
+    };
+    return this.account.makeSwapCollateralTx(fullParams);
+  }
+  /**
+   * Creates a swap debt transaction with auto-injected client data.
+   *
+   * Swaps one debt type for another (e.g., USDC debt -> SOL debt) using a flash loan
+   * so account health is not affected during the swap.
+   *
+   * Auto-injects: program, marginfiAccount, bankMap, oraclePrices, bankMetadataMap, addressLookupTables
+   *
+   * @param params - Swap debt parameters (user provides: connection, repayOpts, borrowOpts, swapOpts, etc.)
+   */
+  async makeSwapDebtTx(params) {
+    const fullParams = {
+      ...params,
+      program: this.client.program,
+      marginfiAccount: this.account,
+      bankMap: this.client.bankMap,
+      oraclePrices: this.client.oraclePriceByBank,
+      bankMetadataMap: this.client.bankIntegrationMap,
+      addressLookupTableAccounts: this.client.addressLookupTables
+    };
+    return this.account.makeSwapDebtTx(fullParams);
+  }
   /**
    * Creates a deposit transaction with auto-injected client data.
    *
@@ -47902,16 +48633,23 @@ var Project0Client = class _Project0Client {
    * @param accountAddress - The public key of the marginfi account
    * @returns A wrapped account ready to use
    */
-  async fetchAccount(accountAddress) {
-    const bankMap = new Map(this.banks.map((b) => [b.address.toBase58(), b]));
-    const { marginfiAccount } = await fetchMarginfiAccountData(
-      this.program,
+  async fetchAccount(accountAddress, skipHealthCache) {
+    const marginfiAccountRaw = await this.program.account.marginfiAccount.fetch(accountAddress);
+    let marginfiAccountParsed = MarginfiAccount.fromAccountParsed(
       accountAddress,
-      bankMap,
-      this.bankIntegrationMap
+      marginfiAccountRaw
     );
-    const account = MarginfiAccount.fromAccountType(marginfiAccount);
-    return new MarginfiAccountWrapper(account, this);
+    if (!skipHealthCache) {
+      const bankMap = new Map(this.banks.map((b) => [b.address.toBase58(), b]));
+      const { account: simulatedAccount } = await marginfiAccountParsed.simulateHealthCache(
+        this.program,
+        bankMap,
+        this.oraclePriceByBank,
+        this.bankIntegrationMap
+      );
+      marginfiAccountParsed = simulatedAccount;
+    }
+    return new MarginfiAccountWrapper(marginfiAccountParsed, this);
   }
   static async initialize(connection, config) {
     const { groupPk, programId } = config;
@@ -48269,6 +49007,8 @@ exports.makeRepayTx = makeRepayTx;
 exports.makeRepayWithCollatTx = makeRepayWithCollatTx;
 exports.makeSetupIx = makeSetupIx;
 exports.makeSmartCrankSwbFeedIx = makeSmartCrankSwbFeedIx;
+exports.makeSwapCollateralTx = makeSwapCollateralTx;
+exports.makeSwapDebtTx = makeSwapDebtTx;
 exports.makeTxPriorityIx = makeTxPriorityIx;
 exports.makeUnwrapSolIx = makeUnwrapSolIx;
 exports.makeUpdateDriftMarketIxs = makeUpdateDriftMarketIxs;