@carrot-protocol/clend-rpc 0.0.1-mrgn-fork1-dev-7be6ef2

package/src/rpc.ts

@@ -0,0 +1,1296 @@
+import { AnchorProvider, Wallet, web3, BN } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+import { Instructions, GroupConfig } from "./instructions";
+import { getAssociatedTokenAddressSync } from "@solana/spl-token";
+import {
+  wrappedI80F48toBigNumber,
+  parseBankConfig,
+  getClendAccountRemainingAccounts,
+  getClendAccountActiveBanks,
+  getTokenProgramForMint,
+  getTokenDecimalsForMint,
+} from "./utils";
+import { getFeeStatePda, getBankPda } from "./addresses";
+import {
+  BankConfigCompact,
+  ClendGroup,
+  Bank,
+  ClendAccount,
+  FeeState,
+  Balance,
+  newClendAccountBalance,
+  InterestRateConfigCompact,
+  InterestRateConfigOpt,
+} from "./state";
+import {
+  uiToAmount,
+  amountToUi,
+  computeAdjustLeverageAmounts,
+  computeLoopingAmounts,
+  computeMaxLeverage,
+  calculateWeightedLeverage,
+} from "./math";
+import {
+  IJupiterUtils,
+  JupiterUtils,
+  SwapInputs,
+  SwapQuote,
+  SwapIxs,
+} from "./jupiterUtils";
+import { QuoteResponse, SwapMode } from "@jup-ag/api";
+import { computeWithdrawLeverageAmounts } from "./math";
+
+export class ClendClient {
+  readonly connection: web3.Connection;
+  readonly provider: AnchorProvider;
+  readonly instructions: Instructions;
+  private jupiterUtils: IJupiterUtils;
+
+  constructor(
+    connection: web3.Connection,
+    wallet: Wallet,
+    skipPreflight: boolean = false,
+    jupiterUtils?: IJupiterUtils,
+  ) {
+    this.provider = new AnchorProvider(connection, wallet, {
+      commitment: "processed",
+      skipPreflight,
+    });
+    this.connection = connection;
+    this.instructions = new Instructions(this.provider);
+    this.jupiterUtils = jupiterUtils || new JupiterUtils();
+  }
+
+  address(): web3.PublicKey {
+    return this.provider.wallet.publicKey;
+  }
+
+  /**
+   * Get Jupiter price for a token pair
+   */
+  async getJupiterPrice(mint: web3.PublicKey | string): Promise<number> {
+    return this.jupiterUtils.getJupiterPrice(mint);
+  }
+
+  /**
+   * Get Jupiter quote for a swap
+   */
+  async getJupiterQuote(
+    inputMint: web3.PublicKey,
+    outputMint: web3.PublicKey,
+    inputMintDecimals: number,
+    outputMintDecimals: number,
+    inputAmountLamports: Decimal,
+    slippageBps: number,
+    swapMode?: SwapMode,
+  ): Promise<SwapQuote<QuoteResponse>> {
+    return this.jupiterUtils.getJupiterQuote(
+      inputMint,
+      outputMint,
+      inputMintDecimals,
+      outputMintDecimals,
+      inputAmountLamports,
+      slippageBps,
+      swapMode,
+    );
+  }
+
+  /**
+   * Get Jupiter swap instructions
+   */
+  async getJupiterSwap(
+    payer: web3.PublicKey,
+    inputs: SwapInputs,
+    quote: SwapQuote<QuoteResponse>,
+  ): Promise<SwapIxs> {
+    return this.jupiterUtils.getJupiterSwap(payer, inputs, quote);
+  }
+
+  async send(
+    ixns: web3.TransactionInstruction[],
+    additionalSigners: web3.Signer[] = [],
+    additionalLuts: web3.PublicKey[] = [],
+  ): Promise<string> {
+    const { blockhash, lastValidBlockHeight } =
+      await this.connection.getLatestBlockhash({
+        commitment: "confirmed",
+      });
+
+    // dedup
+    const luts = new Set([...additionalLuts]);
+    const lutAccounts: web3.AddressLookupTableAccount[] = [];
+    for (const lut of luts) {
+      const account = (await this.connection.getAddressLookupTable(lut)).value!;
+      lutAccounts.push(account);
+    }
+
+    const msg = new web3.TransactionMessage({
+      payerKey: this.address(),
+      recentBlockhash: blockhash,
+      instructions: [...ixns],
+    }).compileToV0Message(lutAccounts);
+
+    const tx = new web3.VersionedTransaction(msg);
+    const signedTx = await this.provider.wallet.signTransaction(tx);
+    signedTx.sign(additionalSigners);
+
+    try {
+      const txSig = await this.connection.sendRawTransaction(
+        signedTx.serialize(),
+        {
+          skipPreflight: this.provider.opts.skipPreflight, // set at client init
+        },
+      );
+
+      // will throw an error if not found or tx errored
+      await this.confirmTx(txSig, blockhash, lastValidBlockHeight);
+
+      return txSig;
+    } catch (e) {
+      if (e instanceof web3.SendTransactionError) {
+        throw new Error(`tx failed: ${e.logs}`);
+      }
+      throw e;
+    }
+  }
+
+  async confirmTx(
+    txSig: string,
+    blockhash: string,
+    lastValidBlockHeight: number,
+  ): Promise<void> {
+    const result = await this.connection.confirmTransaction(
+      {
+        signature: txSig,
+        lastValidBlockHeight,
+        blockhash,
+      },
+      "confirmed",
+    );
+
+    // check error
+    const err = result.value.err;
+    if (err !== null) {
+      throw new Error(`tx returned an error: ${JSON.stringify(err)}`);
+    }
+  }
+
+  // Group Operations
+  async initializeGroup(
+    clendGroup?: web3.Keypair,
+  ): Promise<{ clendGroup: web3.PublicKey; txSig: string }> {
+    const feeState = getFeeStatePda();
+
+    if (!clendGroup) {
+      clendGroup = web3.Keypair.generate();
+    }
+
+    const ix = await this.instructions.initializeGroup(
+      clendGroup,
+      this.address(),
+      feeState,
+    );
+    const txSig = await this.send([ix], [clendGroup]);
+
+    return { clendGroup: clendGroup.publicKey, txSig };
+  }
+
+  async configureGroup(
+    clendGroup: web3.PublicKey,
+    config: GroupConfig,
+  ): Promise<string> {
+    const ix = await this.instructions.configureGroup(
+      clendGroup,
+      this.address(),
+      config,
+    );
+    return this.send([ix]);
+  }
+
+  // Fee State Operations
+  async initGlobalFeeState(
+    feeWallet: web3.PublicKey,
+    bankInitFlatSolFee: number,
+    programFeeFixed: BN,
+    programFeeRate: BN,
+  ): Promise<string> {
+    const initIx = await this.instructions.initGlobalFeeState(
+      this.address(),
+      feeWallet,
+      bankInitFlatSolFee,
+      programFeeFixed,
+      programFeeRate,
+    );
+    return this.send([initIx]);
+  }
+
+  // Bank Operations
+  async addBank(
+    clendGroup: web3.PublicKey,
+    bankMint: web3.PublicKey,
+    pythOracle: web3.PublicKey,
+    pythOracleFeedId: web3.PublicKey,
+    bankConfig: BankConfigCompact,
+    interestRateConfig: InterestRateConfigCompact,
+  ): Promise<{ bank: web3.PublicKey; txSig: string }> {
+    const tokenProgram = getTokenProgramForMint(bankMint);
+
+    const feeStateAccountData = await this.getFeeState();
+    const globalFeeWallet = feeStateAccountData.globalFeeWallet;
+
+    const { bank, ixns } = await this.instructions.addBank(
+      clendGroup,
+      this.address(),
+      globalFeeWallet,
+      bankMint,
+      tokenProgram,
+      pythOracle,
+      pythOracleFeedId,
+      bankConfig,
+      interestRateConfig,
+    );
+    const txSig = await this.send(ixns);
+    return { bank, txSig };
+  }
+
+  // Account fetching Operations
+  async getClendGroup(clendGroup: web3.PublicKey): Promise<ClendGroup> {
+    const accountInfo = await this.connection.getAccountInfo(clendGroup);
+    if (accountInfo === null) {
+      throw new Error(`clend group not found: ${clendGroup.toString()}`);
+    }
+
+    const data = this.instructions.program.coder.accounts.decode(
+      "clendGroup",
+      accountInfo.data,
+    );
+    return {
+      admin: new web3.PublicKey(data.admin),
+      flags: data.flags,
+      padding: data.padding,
+    };
+  }
+
+  async getBank(bank: web3.PublicKey): Promise<Bank> {
+    const accountInfo = await this.connection.getAccountInfo(bank);
+    if (accountInfo === null) {
+      throw new Error(`bank not found: ${bank.toString()}`);
+    }
+
+    const data = this.instructions.program.coder.accounts.decode(
+      "bank",
+      accountInfo.data,
+    );
+
+    return {
+      key: bank,
+      mint: new web3.PublicKey(data.mint),
+      mintDecimals: data.mintDecimals,
+      group: new web3.PublicKey(data.group),
+      assetShareValue: data.assetShareValue,
+      liabilityShareValue: data.liabilityShareValue,
+      liquidityVault: new web3.PublicKey(data.liquidityVault),
+      liquidityVaultBump: data.liquidityVaultBump,
+      liquidityVaultAuthorityBump: data.liquidityVaultAuthorityBump,
+      insuranceVault: new web3.PublicKey(data.insuranceVault),
+      insuranceVaultBump: data.insuranceVaultBump,
+      insuranceVaultAuthorityBump: data.insuranceVaultAuthorityBump,
+      collectedInsuranceFeesOutstanding: data.collectedInsuranceFeesOutstanding,
+      feeVault: new web3.PublicKey(data.feeVault),
+      feeVaultBump: data.feeVaultBump,
+      feeVaultAuthorityBump: data.feeVaultAuthorityBump,
+      collectedGroupFeesOutstanding: data.collectedGroupFeesOutstanding,
+      totalLiabilityShares: data.totalLiabilityShares,
+      totalAssetShares: data.totalAssetShares,
+      lastUpdate: new BN(data.lastUpdate),
+      config: parseBankConfig(data.config),
+      flags: new BN(data.flags),
+      emissionsRate: new BN(data.emissionsRate),
+      emissionsRemaining: data.emissionsRemaining,
+      emissionsMint: new web3.PublicKey(data.emissionsMint),
+      collectedProgramFeesOutstanding: data.collectedProgramFeesOutstanding,
+    };
+  }
+
+  async getClendAccount(
+    clendAccount: web3.PublicKey,
+  ): Promise<ClendAccount | undefined> {
+    const accountInfo = await this.connection.getAccountInfo(clendAccount);
+    if (accountInfo === null) {
+      return undefined;
+    }
+
+    const data = this.instructions.program.coder.accounts.decode(
+      "clendAccount",
+      accountInfo.data,
+    );
+    const balances: Balance[] = [];
+    for (const balance of data.lendingAccount.balances) {
+      balances.push(newClendAccountBalance(balance));
+    }
+
+    return {
+      authority: new web3.PublicKey(data.authority),
+      group: new web3.PublicKey(data.group),
+      accountFlags: data.accountFlags,
+      lendingAccount: {
+        balances,
+      },
+    };
+  }
+
+  async getFeeState(): Promise<FeeState> {
+    const feeStatePda = getFeeStatePda();
+    const accountInfo = await this.connection.getAccountInfo(feeStatePda);
+    if (accountInfo === null) {
+      throw new Error(`fee state not found: ${feeStatePda.toString()}`);
+    }
+
+    const data = this.instructions.program.coder.accounts.decode(
+      "feeState",
+      accountInfo.data,
+    );
+    return {
+      key: feeStatePda,
+      globalFeeAdmin: new web3.PublicKey(data.globalFeeAdmin),
+      globalFeeWallet: new web3.PublicKey(data.globalFeeWallet),
+      bankInitFlatSolFee: data.bankInitFlatSolFee,
+      programFeeFixed: wrappedI80F48toBigNumber(data.programFeeFixed),
+      programFeeRate: wrappedI80F48toBigNumber(data.programFeeRate),
+    };
+  }
+
+  // Account Operations
+  async initializeClendAccount(
+    clendGroup: web3.PublicKey,
+  ): Promise<{ clendAccount: web3.PublicKey; txSig: string }> {
+    const clendAccount = web3.Keypair.generate();
+
+    const ix = await this.instructions.initializeClendAccount(
+      clendGroup,
+      this.address(),
+      clendAccount,
+    );
+
+    const txSig = await this.send([ix], [clendAccount]);
+
+    return { clendAccount: clendAccount.publicKey, txSig };
+  }
+
+  // Lending Operations
+  async deposit(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    mint: web3.PublicKey,
+    amount: BN,
+    remainingAccounts: web3.AccountMeta[] = [],
+  ): Promise<string> {
+    const bank = getBankPda(clendGroup, mint);
+
+    // Get bank data to access the liquidityVault and mint
+    const bankData = await this.getBank(bank);
+
+    // Get token program
+    const tokenProgram = getTokenProgramForMint(bankData.mint);
+
+    // Derive the associated token account for the signer
+    const signerTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      this.address(),
+      true,
+      tokenProgram,
+    );
+
+    const ix = await this.instructions.deposit(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      bank,
+      signerTokenAccount,
+      tokenProgram,
+      amount,
+      remainingAccounts,
+    );
+    return this.send([ix]);
+  }
+
+  async withdraw(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    mint: web3.PublicKey,
+    amount: BN,
+    withdrawAll: boolean | null = null,
+  ): Promise<string> {
+    const bank = getBankPda(clendGroup, mint);
+
+    // Get token program
+    const tokenProgram = getTokenProgramForMint(mint);
+
+    // Derive the associated token account for the signer
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      this.address(),
+      true,
+      tokenProgram,
+    );
+
+    // get required remaining accounts based on account balance
+    const clendAccountData = await this.getClendAccount(clendAccount);
+    let activeBanks = getClendAccountActiveBanks(clendAccountData!);
+
+    // If withdrawAll is true, remove the target bank from activeBanks
+    // as we wont have a remaining balance after the withdraw operation
+    if (withdrawAll === true) {
+      activeBanks = activeBanks.filter((b) => !b.equals(bank));
+    }
+
+    // fetch all active banks
+    const activeBankData: Bank[] = [];
+    for (const bank of activeBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    const ix = await this.instructions.withdraw(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      bank,
+      destinationTokenAccount,
+      tokenProgram,
+      amount,
+      withdrawAll,
+      remainingAccounts,
+    );
+
+    return this.send([ix]);
+  }
+
+  async borrow(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    mint: web3.PublicKey,
+    amount: BN,
+  ): Promise<string> {
+    const bank = getBankPda(clendGroup, mint);
+
+    // Get bank data to access the liquidityVault and mint
+    const bankData = await this.getBank(bank);
+
+    // Get token program
+    const tokenProgram = getTokenProgramForMint(bankData.mint);
+
+    // Derive the associated token account for the signer
+    const destinationTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      this.address(),
+      true,
+      tokenProgram,
+    );
+
+    // fetch user clendAccount data
+    const clendAccountData = await this.getClendAccount(clendAccount);
+    let clendAccountActiveBanks = getClendAccountActiveBanks(clendAccountData!);
+
+    // add bank to active banks if not already in the array
+    clendAccountActiveBanks = Array.from(
+      new Set([...clendAccountActiveBanks, bank]),
+    );
+
+    const activeBankData: Bank[] = [];
+    for (const bank of clendAccountActiveBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    const ix = await this.instructions.borrow(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      bank,
+      destinationTokenAccount,
+      tokenProgram,
+      amount,
+      remainingAccounts,
+    );
+    return this.send([ix]);
+  }
+
+  async repay(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    mint: web3.PublicKey,
+    amount: BN,
+    repayAll: boolean | null = null,
+  ): Promise<string> {
+    const bank = getBankPda(clendGroup, mint);
+
+    // Get bank data to access the liquidityVault and mint
+    const bankData = await this.getBank(bank);
+
+    // Get token program
+    const tokenProgram = getTokenProgramForMint(bankData.mint);
+
+    // Derive the associated token account for the signer
+    const userTokenAccount = getAssociatedTokenAddressSync(
+      bankData.mint,
+      this.address(),
+      true,
+      tokenProgram,
+    );
+
+    const clendAccountData = await this.getClendAccount(clendAccount);
+    const clendAccountActiveBanks = getClendAccountActiveBanks(
+      clendAccountData!,
+    );
+
+    const activeBankData: Bank[] = [];
+    for (const bank of clendAccountActiveBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    const ix = await this.instructions.repay(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      bank,
+      userTokenAccount,
+      tokenProgram,
+      amount,
+      repayAll,
+      remainingAccounts,
+    );
+
+    return this.send([ix]);
+  }
+
+  async editGlobalFeeWallet(
+    newGlobalFeeWallet: web3.PublicKey,
+  ): Promise<string> {
+    const ix = await this.instructions.editGlobalFeeWallet(
+      this.address(),
+      newGlobalFeeWallet,
+    );
+    return this.send([ix]);
+  }
+
+  async configureBankInterestRate(
+    clendGroup: web3.PublicKey,
+    bank: web3.PublicKey,
+    interestRateConfig: InterestRateConfigOpt,
+  ): Promise<string> {
+    const ix = await this.instructions.configureBankInterestRate(
+      clendGroup,
+      this.address(),
+      bank,
+      interestRateConfig,
+    );
+    return this.send([ix]);
+  }
+
+  async depositLeverage(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey | null,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    depositAmount: BN,
+    targetLeverage: number,
+    slippageBps: number,
+  ): Promise<string> {
+    // Get token programs
+    const collateralTokenProgram = getTokenProgramForMint(collateralMint);
+    const debtTokenProgram = getTokenProgramForMint(debtMint);
+
+    // Get decimals
+    const collateralDecimals = getTokenDecimalsForMint(collateralMint);
+    const debtDecimals = getTokenDecimalsForMint(debtMint);
+
+    // Get bank addrs
+    const collateralBank = getBankPda(clendGroup, collateralMint);
+    const debtBank = getBankPda(clendGroup, debtMint);
+
+    // Get bank data
+    const collateralBankData = await this.getBank(collateralBank);
+    const debtBankData = await this.getBank(debtBank);
+
+    const { maxLeverage, ltv } = computeMaxLeverage(
+      wrappedI80F48toBigNumber(collateralBankData.config.assetWeightInit),
+      wrappedI80F48toBigNumber(debtBankData.config.liabilityWeightInit),
+    );
+
+    // Derive token accounts
+    const userCollateralAta = getAssociatedTokenAddressSync(
+      collateralMint,
+      this.address(),
+      true,
+      collateralTokenProgram,
+    );
+    const userDebtAta = getAssociatedTokenAddressSync(
+      debtMint,
+      this.address(),
+      true,
+      debtTokenProgram,
+    );
+
+    // Calculate borrow amount based on target leverage
+    const depositAmountUI = amountToUi(depositAmount, collateralDecimals);
+
+    // Get current prices from Jupiter
+    const collateralPrice = await this.getJupiterPrice(collateralMint);
+    const debtPrice = await this.getJupiterPrice(debtMint);
+
+    // Calculate collateral value in debt token terms
+    const { borrowAmountUi } = computeLoopingAmounts(
+      depositAmountUI,
+      targetLeverage,
+      collateralPrice,
+      debtPrice,
+      wrappedI80F48toBigNumber(collateralBankData.config.assetWeightInit),
+      wrappedI80F48toBigNumber(debtBankData.config.liabilityWeightInit),
+    );
+    const borrowAmount = uiToAmount(borrowAmountUi, debtDecimals);
+
+    // Get Jupiter quote for swapping debt token to collateral token
+    const swapMode = SwapMode.ExactIn;
+    const swapQuote = await this.getJupiterQuote(
+      debtMint,
+      collateralMint,
+      debtDecimals,
+      collateralDecimals,
+      new Decimal(borrowAmount.toString()),
+      slippageBps,
+      swapMode,
+    );
+
+    let activeBanks: web3.PublicKey[] = [];
+    const additionalSigners: web3.Keypair[] = [];
+    let initClendAccountIx: web3.TransactionInstruction | undefined = undefined;
+    if (clendAccount === null) {
+      console.log("Creating init clend account ix");
+
+      // create clend account
+      const clendAccountKp = web3.Keypair.generate();
+      const ix = await this.instructions.initializeClendAccount(
+        clendGroup,
+        this.address(),
+        clendAccountKp,
+      );
+      initClendAccountIx = ix;
+      additionalSigners.push(clendAccountKp);
+      clendAccount = clendAccountKp.publicKey;
+    } else {
+      // Get account data to determine active banks
+      const clendAccountData = await this.getClendAccount(clendAccount);
+      if (!clendAccountData) {
+        throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+      }
+      activeBanks.push(...getClendAccountActiveBanks(clendAccountData));
+    }
+
+    // Add both banks to active banks if not already in the array
+    // dedup with set
+    activeBanks = Array.from(
+      new Set([...activeBanks, debtBank, collateralBank]), // debt first as we borrow first
+    );
+
+    const activeBankData: Bank[] = [];
+    for (const bank of activeBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    // Get swap instructions
+    const swapInputs = {
+      inputAmountLamports: new Decimal(borrowAmount.toString()),
+      inputMint: debtMint,
+      outputMint: collateralMint,
+    };
+    const swapIxs = await this.getJupiterSwap(
+      this.address(),
+      swapInputs,
+      swapQuote,
+    );
+
+    // Calculate additional collateral from swap
+    const additionalCollateralAmount = new BN(
+      swapQuote.quoteResponse!.outAmount,
+    );
+    const totalCollateralAmount = depositAmount.add(additionalCollateralAmount);
+
+    // Create transaction instructions in correct order
+    const borrowIx = await this.instructions.borrow(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      debtBank,
+      userDebtAta,
+      debtTokenProgram,
+      borrowAmount,
+      remainingAccounts,
+    );
+
+    const depositIx = await this.instructions.deposit(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      collateralBank,
+      userCollateralAta,
+      collateralTokenProgram,
+      totalCollateralAmount,
+      remainingAccounts,
+    );
+
+    // add lending and swap instructions
+    const ixnsWithoutFlashLoan: web3.TransactionInstruction[] = [
+      borrowIx,
+      ...swapIxs.swapIxs,
+      depositIx,
+    ];
+
+    // If the clend account is being created, we need to add 1 to the endIndex
+    const { addInitClendAccountIncrement, initClendAccountIxns } =
+      initClendAccountIx
+        ? {
+            addInitClendAccountIncrement: 1,
+            initClendAccountIxns: [initClendAccountIx],
+          }
+        : { addInitClendAccountIncrement: 0, initClendAccountIxns: [] };
+    const startFlashLoanIncrement = 1;
+    const endIndex = new BN(
+      ixnsWithoutFlashLoan.length +
+        addInitClendAccountIncrement +
+        startFlashLoanIncrement,
+    );
+
+    const { beginFlashLoanIx, endFlashLoanIx } =
+      await this.instructions.createFlashLoanInstructions(
+        clendAccount,
+        this.address(),
+        endIndex,
+        remainingAccounts,
+      );
+
+    const ixns: web3.TransactionInstruction[] = [
+      ...initClendAccountIxns,
+      beginFlashLoanIx,
+      ...ixnsWithoutFlashLoan,
+      endFlashLoanIx,
+    ];
+
+    // Combine all instructions
+    return this.send(ixns, additionalSigners, swapIxs.lookupTables);
+  }
+
+  async withdrawLeverage(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    withdrawAmount: BN,
+    withdrawAll: boolean,
+    slippageBps: number,
+  ): Promise<string> {
+    console.log("\n=== WITHDRAW LEVERAGE ===");
+    console.log(`withdrawAll: ${withdrawAll}`);
+    console.log(`withdrawAmount: ${withdrawAmount.toString()}`);
+    console.log(`slippageBps: ${slippageBps}`);
+
+    // Get token programs
+    const collateralTokenProgram = getTokenProgramForMint(collateralMint);
+    const debtTokenProgram = getTokenProgramForMint(debtMint);
+
+    // Get bank data
+    const collateralBank = getBankPda(clendGroup, collateralMint);
+    const debtBank = getBankPda(clendGroup, debtMint);
+    const collateralBankData = await this.getBank(collateralBank);
+    const debtBankData = await this.getBank(debtBank);
+
+    // Get decimals
+    const collateralDecimals = collateralBankData.mintDecimals;
+    const debtDecimals = debtBankData.mintDecimals;
+
+    // Derive token accounts
+    const userCollateralAta = getAssociatedTokenAddressSync(
+      collateralMint,
+      this.address(),
+      true,
+      collateralTokenProgram,
+    );
+    const userDebtAta = getAssociatedTokenAddressSync(
+      debtMint,
+      this.address(),
+      true,
+      debtTokenProgram,
+    );
+
+    // Get account data
+    const clendAccountData = await this.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    // Find the debt and collateral positions
+    let debtBalance: Balance | undefined;
+    let collateralBalance: Balance | undefined;
+
+    for (const balance of clendAccountData.lendingAccount.balances) {
+      if (balance.bankPk && balance.bankPk.equals(debtBank)) {
+        debtBalance = balance;
+      }
+      if (balance.bankPk && balance.bankPk.equals(collateralBank)) {
+        collateralBalance = balance;
+      }
+    }
+
+    if (!debtBalance || !collateralBalance) {
+      throw new Error("Could not find debt or collateral position in account");
+    }
+
+    // Get the current collateral and debt amounts
+    const collateralAmount = wrappedI80F48toBigNumber(
+      collateralBalance.assetShares,
+    );
+    const debtAmount = wrappedI80F48toBigNumber(debtBalance.liabilityShares);
+    console.log(`collateralAmount: ${collateralAmount}`);
+    console.log(`debtAmount: ${debtAmount}`);
+
+    // For UI display and calculations
+    const collateralAmountUI = amountToUi(collateralAmount, collateralDecimals);
+    const debtAmountUI = amountToUi(debtAmount, debtDecimals);
+
+    // Get current prices
+    const collateralPrice = await this.getJupiterPrice(collateralMint);
+    const debtPrice = await this.getJupiterPrice(debtMint);
+
+    // Determine collateral to withdraw and debt to repay
+    let collateralToWithdraw: BN;
+    let debtToRepay: BN;
+
+    if (withdrawAll) {
+      // If withdrawing all, use full collateral and debt amounts
+      collateralToWithdraw = new BN(Math.floor(collateralAmount));
+      debtToRepay = new BN(Math.floor(debtAmount));
+    } else {
+      // For partial withdrawal, calculate debt to maintain leverage
+      const withdrawAmountUI = amountToUi(withdrawAmount, collateralDecimals);
+
+      // Get the weights for leverage calculation
+      const collateralWeight = wrappedI80F48toBigNumber(
+        collateralBankData.config.assetWeightInit,
+      );
+      const debtWeight = wrappedI80F48toBigNumber(
+        debtBankData.config.liabilityWeightInit,
+      );
+
+      // Calculate leverage-preserving withdrawal
+      const result = computeWithdrawLeverageAmounts(
+        collateralAmountUI,
+        debtAmountUI,
+        withdrawAmountUI,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight,
+      );
+
+      console.log(`Partial withdrawal calculations:`);
+      console.log(`Current leverage: ${result.currentLeverage}`);
+      console.log(`Debt to repay: ${result.debtToRepay}`);
+      console.log(`New predicted leverage: ${result.newLeverage}`);
+
+      // Set the amounts to withdraw and repay
+      collateralToWithdraw = withdrawAmount;
+      debtToRepay = uiToAmount(result.debtToRepay, debtDecimals);
+
+      // Add a small buffer for interest accrual
+      debtToRepay = debtToRepay.add(new BN(1));
+    }
+
+    // Get remaining accounts for flash loan
+    let activeBanks = getClendAccountActiveBanks(clendAccountData);
+
+    // If withdrawAll is true, remove both banks from activeBanks
+    if (withdrawAll) {
+      activeBanks = activeBanks.filter(
+        (b) => !b.equals(collateralBank) && !b.equals(debtBank),
+      );
+    }
+
+    const activeBankData: Bank[] = [];
+    for (const bank of activeBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    // Get Jupiter quote for swapping collateral to debt token (ExactOut mode)
+    console.log(`Getting Jupiter quote for swapping collateral to debt...`);
+    const swapMode = SwapMode.ExactOut;
+    const swapQuote = await this.getJupiterQuote(
+      collateralMint,
+      debtMint,
+      collateralDecimals,
+      debtDecimals,
+      new Decimal(debtToRepay.toString()),
+      slippageBps,
+      swapMode,
+    );
+
+    // Calculate how much collateral we need to swap for debt repayment
+    const collateralToSwap = new BN(swapQuote.quoteResponse!.inAmount);
+    console.log(`Collateral needed for swap: ${collateralToSwap.toString()}`);
+    console.log(`Collateral to withdraw: ${collateralToWithdraw.toString()}`);
+
+    // Get swap instructions
+    const swapInputs = {
+      inputAmountLamports: new Decimal(collateralToSwap.toString()),
+      inputMint: collateralMint,
+      outputMint: debtMint,
+    };
+    const swapIxs = await this.getJupiterSwap(
+      this.address(),
+      swapInputs,
+      swapQuote,
+    );
+
+    // Create withdraw instruction
+    console.log(`Creating withdrawal instruction...`);
+    const withdrawIx = await this.instructions.withdraw(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      collateralBank,
+      userCollateralAta,
+      collateralTokenProgram,
+      collateralToWithdraw,
+      withdrawAll,
+      remainingAccounts,
+    );
+
+    // Create repay instruction
+    console.log(`Creating repay instruction...`);
+    const repayIx = await this.instructions.repay(
+      clendGroup,
+      clendAccount,
+      this.address(),
+      debtBank,
+      userDebtAta,
+      debtTokenProgram,
+      debtToRepay,
+      withdrawAll,
+      remainingAccounts,
+    );
+
+    // Assemble all instructions without flash loan
+    const ixnsWithoutFlashLoan: web3.TransactionInstruction[] = [
+      withdrawIx,
+      ...swapIxs.swapIxs,
+      repayIx,
+    ];
+
+    // Create flash loan instructions
+    const endIndex = new BN(ixnsWithoutFlashLoan.length + 1);
+    const { beginFlashLoanIx, endFlashLoanIx } =
+      await this.instructions.createFlashLoanInstructions(
+        clendAccount,
+        this.address(),
+        endIndex,
+        remainingAccounts,
+      );
+
+    // Assemble all instructions in the correct order
+    const instructions = [
+      beginFlashLoanIx,
+      ...ixnsWithoutFlashLoan,
+      endFlashLoanIx,
+    ];
+
+    // Send transaction
+    console.log(`Sending transaction...`);
+    return this.send(instructions, [], swapIxs.lookupTables);
+  }
+
+  async adjustLeverage(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    targetLeverage: number,
+    slippageBps: number,
+  ): Promise<string> {
+    // Get token programs
+    const collateralTokenProgram = getTokenProgramForMint(collateralMint);
+    const debtTokenProgram = getTokenProgramForMint(debtMint);
+
+    // Get bank data
+    const collateralBank = getBankPda(clendGroup, collateralMint);
+    const debtBank = getBankPda(clendGroup, debtMint);
+    const collateralBankData = await this.getBank(collateralBank);
+    const debtBankData = await this.getBank(debtBank);
+
+    // Derive token accounts
+    const userCollateralAta = getAssociatedTokenAddressSync(
+      collateralMint,
+      this.address(),
+      true,
+      collateralTokenProgram,
+    );
+    const userDebtAta = getAssociatedTokenAddressSync(
+      debtMint,
+      this.address(),
+      true,
+      debtTokenProgram,
+    );
+
+    // Get account data to determine current positions
+    const clendAccountData = await this.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    // Find the debt and collateral positions
+    let debtBalance: Balance | undefined;
+    let collateralBalance: Balance | undefined;
+
+    for (const balance of clendAccountData.lendingAccount.balances) {
+      if (balance.bankPk && balance.bankPk.equals(debtBank)) {
+        debtBalance = balance;
+      }
+      if (balance.bankPk && balance.bankPk.equals(collateralBank)) {
+        collateralBalance = balance;
+      }
+    }
+
+    if (!debtBalance || !collateralBalance) {
+      throw new Error("Could not find debt or collateral position in account");
+    }
+
+    // Calculate current leverage
+    const collateralDecimals = collateralBankData.mintDecimals;
+    const debtDecimals = debtBankData.mintDecimals;
+
+    // Get current prices from Jupiter
+    const collateralPrice = await this.getJupiterPrice(collateralMint);
+    const debtPrice = await this.getJupiterPrice(debtMint);
+
+    // Convert to UI amounts for calculations
+    const collateralAmountUI =
+      wrappedI80F48toBigNumber(collateralBalance.assetShares) /
+      10 ** collateralDecimals;
+    const debtAmountUI =
+      wrappedI80F48toBigNumber(debtBalance.liabilityShares) /
+      10 ** debtDecimals;
+
+    // Calculate current leverage and values
+    const collateralValue = collateralAmountUI * collateralPrice;
+    const debtValue = debtAmountUI * debtPrice;
+    const currentLeverage = calculateWeightedLeverage(
+      collateralAmountUI,
+      collateralPrice,
+      wrappedI80F48toBigNumber(collateralBankData.config.assetWeightInit),
+      debtAmountUI,
+      debtPrice,
+      wrappedI80F48toBigNumber(debtBankData.config.liabilityWeightInit),
+    );
+
+    console.log(`=== ADJUST LEVERAGE DIAGNOSTICS ===`);
+    console.log(
+      `Current collateral: ${collateralAmountUI} (${collateralValue} USD)`,
+    );
+    console.log(`Current debt: ${debtAmountUI} (${debtValue} USD)`);
+    console.log(`Current leverage: ${currentLeverage}`);
+    console.log(`Target leverage: ${targetLeverage}`);
+
+    const { collateralDelta, debtDelta, isIncrease } =
+      computeAdjustLeverageAmounts(
+        collateralAmountUI,
+        debtAmountUI,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage,
+      );
+
+    console.log(`isIncrease from calculation: ${isIncrease}`);
+    console.log(`collateralDelta: ${collateralDelta}`);
+    console.log(`debtDelta: ${debtDelta}`);
+
+    // Get remaining accounts for flash loan
+    let activeBanks = getClendAccountActiveBanks(clendAccountData);
+
+    // Add both banks to active banks if not already in the array
+    activeBanks = Array.from(
+      new Set([...activeBanks, collateralBank, debtBank]),
+    );
+
+    const activeBankData: Bank[] = [];
+    for (const bank of activeBanks) {
+      const bankData = await this.getBank(bank);
+      activeBankData.push(bankData);
+    }
+
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    // Prepare transaction instructions
+    const instructions: web3.TransactionInstruction[] = [];
+    let swapLookupTables: web3.PublicKey[] = [];
+
+    if (isIncrease) {
+      console.log(`Increasing leverage`);
+
+      // Calculate amounts for increasing leverage
+      const additionalDebtAmountUI = debtDelta * debtPrice;
+      const additionalDebtAmount = uiToAmount(
+        additionalDebtAmountUI,
+        debtDecimals,
+      );
+
+      // Get Jupiter quote for swapping debt token to collateral token
+      const swapMode = SwapMode.ExactIn;
+      const swapQuote = await this.getJupiterQuote(
+        debtMint,
+        collateralMint,
+        debtDecimals,
+        collateralDecimals,
+        new Decimal(additionalDebtAmount.toString()),
+        slippageBps,
+        swapMode,
+      );
+
+      // Get swap instructions
+      const swapInputs = {
+        inputAmountLamports: new Decimal(additionalDebtAmount.toString()),
+        inputMint: debtMint,
+        outputMint: collateralMint,
+      };
+      const swapIxs = await this.getJupiterSwap(
+        this.address(),
+        swapInputs,
+        swapQuote,
+      );
+
+      // Borrow more debt
+      const borrowIx = await this.instructions.borrow(
+        clendGroup,
+        clendAccount,
+        this.address(),
+        debtBank,
+        userDebtAta,
+        debtTokenProgram,
+        additionalDebtAmount,
+        remainingAccounts,
+      );
+
+      // Calculate additional collateral from swap
+      const additionalCollateralAmount = new BN(
+        swapQuote.quoteResponse!.outAmount,
+      );
+
+      // Deposit additional collateral
+      const depositIx = await this.instructions.deposit(
+        clendGroup,
+        clendAccount,
+        this.address(),
+        collateralBank,
+        userCollateralAta,
+        collateralTokenProgram,
+        additionalCollateralAmount,
+        remainingAccounts,
+      );
+
+      instructions.push(borrowIx, ...swapIxs.swapIxs, depositIx);
+      swapLookupTables = swapIxs.lookupTables;
+    } else {
+      console.log(`Decreasing leverage`);
+      // Calculate amounts for decreasing leverage
+      const debtToReduceAmount = new BN(
+        Math.floor(debtDelta * 10 ** debtDecimals),
+      );
+
+      // Get Jupiter quote for swapping collateral token to debt token with ExactOut
+      const swapMode = SwapMode.ExactOut;
+      const swapQuote = await this.getJupiterQuote(
+        collateralMint,
+        debtMint,
+        collateralDecimals,
+        debtDecimals,
+        new Decimal(debtToReduceAmount.toString()),
+        slippageBps,
+        swapMode,
+      );
+
+      // Calculate how much collateral we need to swap to repay the debt
+      const collateralToSwap = new BN(swapQuote.quoteResponse!.inAmount);
+
+      // Get swap instructions
+      const swapInputs = {
+        inputAmountLamports: new Decimal(collateralToSwap.toString()),
+        inputMint: collateralMint,
+        outputMint: debtMint,
+      };
+      const swapIxs = await this.getJupiterSwap(
+        this.address(),
+        swapInputs,
+        swapQuote,
+      );
+
+      // Withdraw collateral
+      const withdrawIx = await this.instructions.withdraw(
+        clendGroup,
+        clendAccount,
+        this.address(),
+        collateralBank,
+        userCollateralAta,
+        collateralTokenProgram,
+        collateralToSwap,
+        false,
+        remainingAccounts,
+      );
+      console.log("withdraw ix created");
+
+      // Repay debt
+      const repayIx = await this.instructions.repay(
+        clendGroup,
+        clendAccount,
+        this.address(),
+        debtBank,
+        userDebtAta,
+        debtTokenProgram,
+        debtToReduceAmount,
+        false,
+        remainingAccounts,
+      );
+      console.log("repay ix created");
+
+      instructions.push(withdrawIx, ...swapIxs.swapIxs, repayIx);
+      swapLookupTables = swapIxs.lookupTables;
+    }
+
+    const endIndex = new BN(instructions.length + 1);
+
+    const { beginFlashLoanIx, endFlashLoanIx } =
+      await this.instructions.createFlashLoanInstructions(
+        clendAccount,
+        this.address(),
+        endIndex,
+        remainingAccounts,
+      );
+
+    // Create a new array with the flash loan instructions wrapping the existing instructions
+    const finalInstructions = [
+      beginFlashLoanIx,
+      ...instructions,
+      endFlashLoanIx,
+    ];
+
+    // Send transaction
+    return this.send(finalInstructions, [], swapLookupTables);
+  }
+}