@carrot-protocol/clend-vaults-rpc 0.0.2-pub1-dev-a741874

package/src/rpc.ts

@@ -0,0 +1,1354 @@
+// rpc.ts
+import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import {
+  AuthorityType,
+  createInitializeInstruction,
+  createSetAuthorityInstruction,
+  getAssociatedTokenAddressSync,
+  MintLayout,
+  RawMint,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  unpackMint,
+} from "@solana/spl-token";
+import { Decimal } from "decimal.js";
+
+import { AddAssetArgs, ClendVaultsProgram } from "./program";
+import {
+  CLEND_VAULTS_PROGRAM_ID,
+  getVaultPda,
+  JUPITER_SWAP_PROGRAM_ID,
+} from "./addresses";
+
+import {
+  getBankPda,
+  getBankLiquidityVaultPda,
+  getBankLiquidityVaultAuthorityPda,
+  CLEND_PROGRAM_ID,
+  getClendAccountRemainingAccounts,
+  ClendClient,
+  getClendAccountActiveBanks,
+  Bank,
+  ISwapper,
+  getTokenProgramForMint,
+  getTokenProgramForMintFromRpc,
+  BankFlags,
+} from "@carrot-protocol/clend-rpc";
+import {
+  Vault,
+  VaultAsset,
+  VaultAssetReserve,
+  VaultClendAccount,
+  VaultEquity,
+  parseVaultAccount,
+} from "./state";
+import { ClendVaultsJupSwapper } from "./swapper";
+import {
+  amountToUi,
+  calculateLendingAccountEquity,
+  calculateVaultNav,
+  convertSharesToAsset,
+  uiToAmount,
+} from "./math";
+
+export type Wallet = AnchorProvider["wallet"];
+type AccountMeta = web3.AccountMeta;
+
+export class ClendVaultsClient {
+  readonly connection: Connection;
+  readonly program: ClendVaultsProgram;
+  readonly clendClient: ClendClient;
+  readonly swapper: ISwapper;
+  readonly skipPreflight: boolean;
+
+  constructor(
+    provider: AnchorProvider,
+    skipPreflight: boolean = false,
+    swapperOverride?: ISwapper,
+  ) {
+    this.connection = provider.connection;
+    this.program = new ClendVaultsProgram(provider);
+    this.skipPreflight = skipPreflight;
+    this.clendClient = new ClendClient(
+      provider.connection,
+      provider.wallet as any,
+      skipPreflight,
+      0,
+    );
+    this.swapper =
+      swapperOverride || new ClendVaultsJupSwapper(this.connection);
+  }
+
+  address(): web3.PublicKey {
+    return this.program.program.provider.publicKey!;
+  }
+
+  async getVault(vault: web3.PublicKey): Promise<Vault> {
+    const vaultAccountInfo = await this.connection.getAccountInfo(vault);
+    if (!vaultAccountInfo) {
+      throw new Error(`Vault account not found: ${vault.toString()}`);
+    }
+    return parseVaultAccount(vault, vaultAccountInfo, this.connection);
+  }
+
+  async getVaultEquity(vault: Vault): Promise<VaultEquity> {
+    let vaultEquity = 0;
+    const clendAccountEquity: { address: web3.PublicKey; equity: number }[] =
+      [];
+
+    // calculate equity for each clend account
+    for (const clendAccount of vault.clendAccounts) {
+      const clendAccountData = await this.clendClient.getClendAccount(
+        clendAccount.address,
+      );
+      if (!clendAccountData) {
+        throw new Error(
+          `Clend account not found: ${clendAccount.address.toString()}`,
+        );
+      }
+
+      const lendingAccountEquity = calculateLendingAccountEquity(
+        clendAccountData.lendingAccount,
+      );
+      clendAccountEquity.push({
+        address: clendAccount.address,
+        equity: lendingAccountEquity,
+      });
+      vaultEquity += lendingAccountEquity;
+    }
+
+    // calculate equity for each reserve
+    const reserveEquity: { address: web3.PublicKey; equity: number }[] = [];
+    for (const asset of vault.assets) {
+      const mint = asset.mint.address;
+      const priceUi = await this.clendClient.getPythOraclePrice(mint);
+      const rEquity = priceUi * asset.reserve.amountUi;
+      reserveEquity.push({ address: asset.reserve.address, equity: rEquity });
+      vaultEquity += rEquity;
+    }
+
+    return {
+      address: vault.address,
+      vaultEquity,
+      clendAccountEquity,
+      reserveEquity,
+    };
+  }
+
+  async initVault(
+    sharesMint: web3.PublicKey,
+    managementFeeBps: number,
+  ): Promise<{ txSig: string; vault: web3.PublicKey }> {
+    const { vault, ixns: initVaultIxns } = await this.program.initVault(
+      sharesMint,
+      this.address(),
+      managementFeeBps,
+    );
+
+    const initializeTxSig = await this.send(initVaultIxns);
+
+    return { txSig: initializeTxSig, vault };
+  }
+
+  async addAsset(
+    vault: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    assetOracle: web3.PublicKey,
+    addAssetArgs: AddAssetArgs,
+  ): Promise<string> {
+    const ixns = await this.program.addAsset(
+      vault,
+      this.address(),
+      assetMint,
+      assetOracle,
+      TOKEN_PROGRAM_ID,
+      addAssetArgs,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async addClendAccount(
+    vault: web3.PublicKey,
+    clendGroup: web3.PublicKey,
+  ): Promise<{ txSig: string; clendAccount: web3.PublicKey }> {
+    const clendAccount = web3.Keypair.generate();
+
+    const addClendAccountIxns = await this.program.addClendAccount(
+      vault,
+      this.address(),
+      clendGroup,
+      clendAccount,
+    );
+
+    const txSig = await this.send([...addClendAccountIxns], [clendAccount]);
+
+    return { txSig, clendAccount: clendAccount.publicKey };
+  }
+
+  async updateVaultManager(
+    vault: web3.PublicKey,
+    newManager: web3.PublicKey,
+  ): Promise<web3.TransactionInstruction[]> {
+    return this.program.updateVaultManager(vault, this.address(), newManager);
+  }
+
+  async issue(
+    vault: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<string> {
+    const ixns = await this.prepareIssueIxns(
+      this.address(),
+      vault,
+      assetMint,
+      amount,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async prepareIssueIxns(
+    user: web3.PublicKey,
+    vault: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<web3.TransactionInstruction[]> {
+    // get vault and asset data
+    const vaultData = await this.getVault(vault);
+    const assetData = vaultData.assets.find((a) =>
+      a.mint.address.equals(assetMint),
+    )!;
+
+    const remainingAccounts = await buildEquityRemainingAccounts(
+      vaultData,
+      this.clendClient,
+    );
+
+    const ixns = await this.program.issue(
+      vault,
+      vaultData.sharesMint,
+      user,
+      assetMint,
+      assetData.oracle,
+      amount,
+      TOKEN_PROGRAM_ID,
+      TOKEN_2022_PROGRAM_ID,
+      remainingAccounts,
+    );
+
+    return ixns;
+  }
+
+  async redeem(
+    vault: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    sharesAmount: BN,
+  ): Promise<string> {
+    const ixns = await this.prepareRedeemIxns(
+      this.address(),
+      vault,
+      assetMint,
+      sharesAmount,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async prepareRedeemIxns(
+    user: web3.PublicKey,
+    vault: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<web3.TransactionInstruction[]> {
+    const vaultData = await this.getVault(vault);
+    const assetData = vaultData.assets.find((a) =>
+      a.mint.address.equals(assetMint),
+    )!;
+
+    const remainingAccounts = await buildEquityRemainingAccounts(
+      vaultData,
+      this.clendClient,
+    );
+
+    return this.program.redeem(
+      vault,
+      vaultData.sharesMint,
+      user,
+      assetMint,
+      assetData.oracle,
+      amount,
+      TOKEN_PROGRAM_ID,
+      TOKEN_2022_PROGRAM_ID,
+      remainingAccounts,
+    );
+  }
+
+  async clendAccountDeposit(
+    vault: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<string> {
+    // fetch clend account data
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    // fetch vault data
+    const vaultData = await this.getVault(vault);
+    const assetData = vaultData.assets.find((a) =>
+      a.mint.address.equals(assetMint),
+    )!;
+
+    // remaining accounts for protocol call
+    const ra = getClendAccountRemainingAccounts([]);
+
+    const ixns = await this.program.clendAccountDeposit(
+      vault,
+      this.address(),
+      clendAccountData.group,
+      clendAccount,
+      assetMint,
+      TOKEN_PROGRAM_ID,
+      amount,
+      assetData.reserve.address,
+      ra,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async clendAccountWithdraw(
+    vault: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<string> {
+    // fetch clend account data
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    // fetch active banks
+    const clendAccountActiveBanks =
+      getClendAccountActiveBanks(clendAccountData);
+
+    const activeBankData: Bank[] = [];
+    for (const bank of clendAccountActiveBanks) {
+      const bankData = await this.clendClient.getBank(bank);
+      activeBankData.push(bankData);
+    }
+
+    const ra = getClendAccountRemainingAccounts(activeBankData);
+
+    const ixns = await this.program.clendAccountWithdraw(
+      vault,
+      this.address(),
+      clendAccountData.group,
+      clendAccount,
+      assetMint,
+      TOKEN_PROGRAM_ID,
+      amount,
+      ra,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async clendAccountRepay(
+    vault: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN | number,
+  ): Promise<string> {
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    const ra = getClendAccountRemainingAccounts([]);
+
+    const ixns = await this.program.clendAccountRepay(
+      vault,
+      this.address(),
+      clendAccountData.group,
+      clendAccount,
+      assetMint,
+      TOKEN_PROGRAM_ID,
+      amount,
+      ra,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async clendAccountBorrow(
+    vault: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    amount: BN,
+  ): Promise<string> {
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    // fetch active banks
+    const clendAccountActiveBanks =
+      getClendAccountActiveBanks(clendAccountData);
+
+    // add target bank if not already in list
+    // this would be the case for a first time borrow
+    const targetBank = getBankPda(clendAccountData.group, assetMint);
+    const alreadyInBankList = clendAccountActiveBanks.some((c) =>
+      c.equals(targetBank),
+    );
+    if (!alreadyInBankList) {
+      clendAccountActiveBanks.push(targetBank);
+    }
+
+    const activeBankData: Bank[] = [];
+    for (const bank of clendAccountActiveBanks) {
+      const bankData = await this.clendClient.getBank(bank);
+      activeBankData.push(bankData);
+    }
+
+    const ra = getClendAccountRemainingAccounts(activeBankData);
+
+    const ixns = await this.program.clendAccountBorrow(
+      vault,
+      this.address(),
+      clendAccountData.group,
+      clendAccount,
+      assetMint,
+      TOKEN_PROGRAM_ID,
+      amount,
+      ra,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async clendAccountClaimEmissions(
+    vault: web3.PublicKey,
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    bank: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    emissionsMint: web3.PublicKey,
+  ): Promise<web3.TransactionInstruction[]> {
+    const emissionsVault = getBankLiquidityVaultPda(bank);
+    const emissionsAuthority = getBankLiquidityVaultAuthorityPda(bank);
+
+    // destination is an ATA owned by the vault PDA
+    const destinationAccount = getAssociatedTokenAddressSync(
+      emissionsMint,
+      vault,
+      true,
+      TOKEN_PROGRAM_ID,
+    );
+
+    return this.program.clendAccountClaimEmissions(
+      vault,
+      this.address(),
+      clendGroup,
+      clendAccount,
+      bank,
+      assetMint,
+      emissionsMint,
+      destinationAccount,
+      TOKEN_PROGRAM_ID,
+      emissionsVault,
+      emissionsAuthority,
+      CLEND_PROGRAM_ID,
+    );
+  }
+
+  // adjust the leverage of the clend account
+  async clendAccountAdjustLeverage(
+    clendAccount: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    targetLeverage: number,
+    slippageBps: number,
+  ): Promise<string> {
+    const clendAccountState =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountState) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    const adjustLeverageTxSig = await this.clendClient.adjustLeverage(
+      clendAccountState.group,
+      clendAccount,
+      collateralMint,
+      debtMint,
+      targetLeverage,
+      slippageBps,
+      this.swapper,
+    );
+
+    return adjustLeverageTxSig;
+  }
+
+  // create instructions for redeeming shares
+  // however this will pull from a clend account balance
+  // the equity value of the shares desired for redemption
+  async prepareRedeemFromClendAccountIxns(
+    user: web3.PublicKey,
+    vault: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    outputAssetMint: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    totalSharesToRedeem: BN,
+    sharesToRedeemFromClendAccount: BN,
+    slippageBps: number,
+  ): Promise<{ ixns: web3.TransactionInstruction[]; luts: web3.PublicKey[] }> {
+    const vaultState = await this.getVault(vault);
+    const outputAssetState = vaultState.assets.find((a) =>
+      a.mint.address.equals(outputAssetMint),
+    );
+    if (!outputAssetState) {
+      throw new Error(
+        `output asset mint ${outputAssetMint.toString()} not found in vault ${vault.toString()}`,
+      );
+    }
+
+    // get price of output asset
+    const priceUi = await this.clendClient.getPythOraclePrice(
+      outputAssetState.mint.address,
+    );
+
+    const vaultEquity = await this.getVaultEquity(vaultState);
+
+    const sharesSupplyUi = amountToUi(
+      vaultState.sharesSupply,
+      vaultState.sharesDecimals,
+    );
+    const sharesToRedeemFromClendAccountUi = amountToUi(
+      sharesToRedeemFromClendAccount,
+      vaultState.sharesDecimals,
+    );
+    const vaultNav = calculateVaultNav(vaultEquity.vaultEquity, sharesSupplyUi);
+
+    // TODO: will need to add fees to this
+    const desiredOutputAmount = convertSharesToAsset(
+      vaultNav,
+      sharesToRedeemFromClendAccountUi,
+      outputAssetState.mint.decimals,
+      priceUi,
+    );
+
+    // check if clend account is listed in vault config
+    const clendAccountIsValid = vaultState.clendAccounts.some((c) =>
+      c.address.equals(clendAccount),
+    );
+    if (!clendAccountIsValid) {
+      throw new Error(
+        `Clend account ${clendAccount.toString()} not found in vault ${vault.toString()} config`,
+      );
+    }
+
+    // fetch clend account state
+    const clendAccountState =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountState) {
+      throw new Error(
+        `error fetching clend account state: ${clendAccount.toString()}`,
+      );
+    }
+
+    // we need to know how many ixns will go before the leverage ixns
+    // this is for the flash loan index positioning
+    let prependedIxCount: number = 0;
+    let cuIxCount: number = 0; // TODO: in the clend libs we already account for this
+    prependedIxCount += cuIxCount;
+
+    // get the redemption ixns
+    // these are run after the withdraw leverage ixns
+    const redeemIxns = await this.prepareRedeemIxns(
+      user,
+      vault,
+      outputAssetMint,
+      totalSharesToRedeem,
+    );
+
+    // calculate parameters for withdraw leverage
+    // based on output asset mint
+    let debtToRepay: BN;
+    let collateralToWithdraw: BN;
+    let debtBankData: Bank;
+    let collateralBankData: Bank;
+    switch (outputAssetMint.toString()) {
+      case collateralMint.toString():
+        // get params for withdraw leverage
+        const {
+          debtToRepay: debtToRepayCollateral,
+          collateralToWithdraw: collateralToWithdrawCollateral,
+          debtBankData: debtBankDataCollateral,
+          collateralBankData: collateralBankDataCollateral,
+        } = await this.clendClient.getNetWithdrawLeverageCollateralParams(
+          clendAccountState.group,
+          clendAccount,
+          collateralMint,
+          debtMint,
+          desiredOutputAmount,
+          false,
+        );
+        debtToRepay = debtToRepayCollateral;
+        collateralToWithdraw = collateralToWithdrawCollateral;
+        debtBankData = debtBankDataCollateral;
+        collateralBankData = collateralBankDataCollateral;
+        break;
+      case debtMint.toString():
+        // get params for withdraw leverage
+        const {
+          debtToRepay: debtToRepayDebt,
+          collateralToWithdraw: collateralToWithdrawDebt,
+          debtBankData: debtBankDataDebt,
+          collateralBankData: collateralBankDataDebt,
+        } = await this.clendClient.getNetWithdrawLeverageDebtParams(
+          clendAccountState.group,
+          clendAccount,
+          collateralMint,
+          debtMint,
+          desiredOutputAmount,
+          false,
+        );
+        debtToRepay = debtToRepayDebt;
+        collateralToWithdraw = collateralToWithdrawDebt;
+        debtBankData = debtBankDataDebt;
+        collateralBankData = collateralBankDataDebt;
+        break;
+      default:
+        throw new Error(
+          `invalid output token mint: ${outputAssetMint.toString()}`,
+        );
+    }
+
+    // compose instructions for user to sign
+    let ixns: web3.TransactionInstruction[] = [];
+    let luts: web3.PublicKey[] = [];
+    switch (outputAssetMint.toString()) {
+      case collateralMint.toString():
+        const { ixns: collateralIxns, luts: collateralLuts } =
+          await this.getWithdrawLeverageCollateralIxns(
+            vault,
+            vaultState.manager,
+            user,
+            clendAccountState.group,
+            clendAccount,
+            collateralMint,
+            debtMint,
+            collateralBankData.mintDecimals,
+            debtBankData.mintDecimals,
+            false,
+            collateralToWithdraw,
+            desiredOutputAmount,
+            debtToRepay,
+            slippageBps,
+            prependedIxCount,
+            this.swapper,
+          );
+        ixns = collateralIxns;
+        luts = collateralLuts;
+        break;
+      case debtMint.toString():
+        const { ixns: debtIxns, luts: debtLuts } =
+          await this.getWithdrawLeverageDebtIxns(
+            vault,
+            vaultState.manager,
+            user,
+            clendAccountState.group,
+            clendAccount,
+            collateralMint,
+            debtMint,
+            collateralBankData.mintDecimals,
+            debtBankData.mintDecimals,
+            false,
+            debtToRepay,
+            collateralToWithdraw,
+            slippageBps,
+            prependedIxCount,
+            this.swapper,
+          );
+        ixns = debtIxns;
+        luts = debtLuts;
+        break;
+      default:
+        throw new Error(
+          `invalid output token mint: ${outputAssetMint.toString()}`,
+        );
+    }
+
+    const allIxns: web3.TransactionInstruction[] = [...ixns, ...redeemIxns];
+
+    return { ixns: allIxns, luts };
+  }
+
+  async getWithdrawLeverageCollateralIxns(
+    vault: web3.PublicKey,
+    vaultManager: web3.PublicKey,
+    user: web3.PublicKey,
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    collateralDecimals: number,
+    debtDecimals: number,
+    withdrawAll: boolean,
+    collateralToWithdraw: BN,
+    desiredNetCollateralToReceive: BN,
+    debtToRepay: BN,
+    slippageBps: number,
+    additionalIxnCount: number,
+    swapperOverride?: ISwapper,
+  ): Promise<{ ixns: web3.TransactionInstruction[]; luts: web3.PublicKey[] }> {
+    // override swapper if provided
+    let activeSwapper = this.swapper;
+    if (swapperOverride) {
+      activeSwapper = swapperOverride;
+    }
+
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    let activeBanks = getClendAccountActiveBanks(clendAccountData);
+    const activeBankData = await this.clendClient.getBanks(activeBanks);
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    // this is for partial withdraws
+    // overriden if withdrawAll is true
+    let collateralToSwap = collateralToWithdraw.sub(
+      desiredNetCollateralToReceive,
+    );
+
+    // again for partial withdraws
+    let swapQuote = await activeSwapper.getQuote({
+      payer: vault,
+      inputMint: collateralMint,
+      inputMintDecimals: collateralDecimals,
+      outputMint: debtMint,
+      outputMintDecimals: debtDecimals,
+      inputAmount: collateralToSwap,
+      slippageBps,
+      swapMode: "ExactIn",
+    });
+
+    if (withdrawAll) {
+      // Step 1: Get the current price via a nominal 1-token quote.
+      const oneToken = uiToAmount(1, collateralDecimals);
+      const nominalQuote = await activeSwapper.getQuote({
+        payer: vault,
+        inputMint: collateralMint,
+        inputMintDecimals: collateralDecimals,
+        outputMint: debtMint,
+        outputMintDecimals: debtDecimals,
+        inputAmount: oneToken,
+        slippageBps,
+        swapMode: "ExactIn",
+      });
+      const outAmountUi = amountToUi(
+        nominalQuote.otherAmountThreshold,
+        debtDecimals,
+      );
+
+      // Step 2: Estimate the ideal collateral needed to cover the debt.
+      const debtToRepayUi = new Decimal(
+        amountToUi(debtToRepay, debtDecimals).toString(),
+      );
+      const collateralToSwapUi_ideal = debtToRepayUi.div(outAmountUi);
+      const collateralToSwap_ideal = uiToAmount(
+        collateralToSwapUi_ideal.toNumber(),
+        collateralDecimals,
+      );
+      collateralToSwap = collateralToSwap_ideal;
+      //collateralToSwap = adjustAmountForSlippage(
+      //  collateralToSwap_ideal,
+      //  slippageBps,
+      //);
+
+      // Step 4 (Final Quote): Get the real quote for the buffered amount.
+      swapQuote = await activeSwapper.getQuote({
+        payer: user,
+        inputMint: collateralMint,
+        inputMintDecimals: collateralDecimals,
+        outputMint: debtMint,
+        outputMintDecimals: debtDecimals,
+        inputAmount: collateralToSwap,
+        slippageBps,
+        swapMode: "ExactIn",
+      });
+
+      // check its sufficient
+      if (swapQuote.outAmount.lt(debtToRepay)) {
+        throw new Error(
+          `Quote is insufficient to cover debt after slippage. Try increasing slippage tolerance.
+          ${swapQuote.otherAmountThreshold.toString()} < ${debtToRepay.toString()}`,
+        );
+      }
+    }
+
+    // 3. The final amount to repay is the minimum we are guaranteed to get from the swap.
+    const finalDebtToRepay = swapQuote.outAmount;
+
+    const swapIxns = await activeSwapper.getSwapIxns(swapQuote);
+
+    const collateralTokenProgram = await getTokenProgramForMintFromRpc(
+      this.connection,
+      collateralMint,
+    );
+    const debtTokenProgram = await getTokenProgramForMintFromRpc(
+      this.connection,
+      debtMint,
+    );
+
+    const withdrawIx = await this.program.clendAccountWithdraw(
+      vault,
+      vaultManager,
+      clendGroup,
+      clendAccount,
+      collateralMint,
+      collateralTokenProgram,
+      collateralToWithdraw,
+      remainingAccounts,
+    );
+
+    // if withdrawAll == true we need to make sure we withdraw emissions from both banks before withdrawing all the bank tokens
+    const emissionsIxns: web3.TransactionInstruction[] = [];
+    if (withdrawAll) {
+      // get bank data
+      const collateralBankData = activeBankData.find((b) =>
+        b.mint.equals(collateralMint),
+      );
+      if (!collateralBankData) {
+        throw new Error(
+          `Collateral bank not found: ${collateralMint.toString()}`,
+        );
+      }
+      const debtBankData = activeBankData.find((b) => b.mint.equals(debtMint));
+      if (!debtBankData) {
+        throw new Error(`Debt bank not found: ${debtMint.toString()}`);
+      }
+
+      //// collateral bank emissions
+      //if (
+      //  !collateralBankData.emissionsMint.equals(web3.PublicKey.default) &&
+      //  (collateralBankData.flags === BankFlags.LendingEmissionsActive ||
+      //    collateralBankData.flags ===
+      //      BankFlags.LendingAndBorrowingEmissionsActive)
+      //) {
+      //  const emissionsMint = collateralBankData.emissionsMint;
+      //  const emissionsMintTokenProgram = await getTokenProgramForMintFromRpc(
+      //    this.connection,
+      //    emissionsMint,
+      //  );
+      //  const withdrawEmissionsIx = await this.program.clendAccountClaimEmissions(
+
+      //    clendGroup,
+      //    clendAccount,
+      //    clendAccountData.authority,
+      //    collateralBank,
+      //    emissionsMint,
+      //    emissionsMintTokenProgram,
+      //  );
+      //  emissionsIxns.push(...withdrawEmissionsIx);
+      //}
+
+      //// debt bank emissions
+      //if (
+      //  !debtBankData.emissionsMint.equals(web3.PublicKey.default) &&
+      //  (debtBankData.flags === BankFlags.BorrowEmissionsActive ||
+      //    debtBankData.flags === BankFlags.LendingAndBorrowingEmissionsActive)
+      //) {
+      //  const emissionsMint = debtBankData.emissionsMint;
+      //  const emissionsMintTokenProgram = await getTokenProgramForMintFromRpc(
+      //    this.connection,
+      //    emissionsMint,
+      //  );
+      //  const withdrawEmissionsIx = await this.program.clendAccountWithdrawEmissions(
+      //    clendGroup,
+      //    clendAccount,
+      //    clendAccountData.authority,
+      //    debtBank,
+      //    emissionsMint,
+      //    emissionsMintTokenProgram,
+      //  );
+      //  emissionsIxns.push(...withdrawEmissionsIx);
+      //}
+    }
+
+    // Create repay instruction with the amount from the 'ExactIn' swap
+    const repayIx = await this.program.clendAccountRepay(
+      vault,
+      vaultManager,
+      clendGroup,
+      clendAccount,
+      debtMint,
+      debtTokenProgram,
+      finalDebtToRepay,
+      remainingAccounts,
+    );
+
+    const ixnsWithoutFlashLoan: web3.TransactionInstruction[] = [
+      ...emissionsIxns,
+      ...withdrawIx,
+      ...swapIxns.ixns,
+      ...repayIx,
+    ];
+
+    const cuIxns = 2;
+    const endIndex = new BN(
+      cuIxns + ixnsWithoutFlashLoan.length + 1 + additionalIxnCount,
+    );
+    const remainingAccountsForFlashLoan =
+      getClendAccountRemainingAccounts(activeBankData);
+
+    const { beginFlashLoanIx, endFlashLoanIx } =
+      await this.clendClient.instructions.createFlashLoanInstructions(
+        clendAccount,
+        user,
+        endIndex,
+        remainingAccountsForFlashLoan,
+      );
+
+    const instructions = [
+      beginFlashLoanIx,
+      ...ixnsWithoutFlashLoan,
+      endFlashLoanIx,
+    ];
+
+    return { ixns: instructions, luts: swapIxns.luts };
+  }
+
+  async getWithdrawLeverageDebtIxns(
+    vault: web3.PublicKey,
+    vaultManager: web3.PublicKey,
+    user: web3.PublicKey,
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    collateralMint: web3.PublicKey,
+    debtMint: web3.PublicKey,
+    collateralDecimals: number,
+    debtDecimals: number,
+    withdrawAll: boolean,
+    debtToRepay: BN,
+    collateralToWithdraw: BN,
+    slippageBps: number,
+    additionalIxnCount: number,
+    swapperOverride?: ISwapper,
+  ): Promise<{ ixns: web3.TransactionInstruction[]; luts: web3.PublicKey[] }> {
+    // override swapper if provided
+    let activeSwapper = this.swapper;
+    if (swapperOverride) {
+      activeSwapper = swapperOverride;
+    }
+
+    const clendAccountData =
+      await this.clendClient.getClendAccount(clendAccount);
+    if (!clendAccountData) {
+      throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+    }
+
+    let activeBanks = getClendAccountActiveBanks(clendAccountData);
+    const activeBankData = await this.clendClient.getBanks(activeBanks);
+    const remainingAccounts = getClendAccountRemainingAccounts(activeBankData);
+
+    // Get a fresh 'ExactIn' quote for swapping the total collateral to withdraw
+    const swapQuote = await activeSwapper.getQuote({
+      payer: vault,
+      inputMint: collateralMint,
+      inputMintDecimals: collateralDecimals,
+      outputMint: debtMint,
+      outputMintDecimals: debtDecimals,
+      inputAmount: collateralToWithdraw,
+      slippageBps,
+      swapMode: "ExactIn",
+    });
+
+    // The minimum amount of debt token we are guaranteed to receive from the swap
+    const minDebtReceivedFromSwap = swapQuote.outAmount;
+
+    // Determine the final amount to repay. It's the lesser of what we need and what we're guaranteed to get.
+    const finalDebtToRepay = BN.min(debtToRepay, minDebtReceivedFromSwap);
+
+    // Get Swap Instructions from the swapper
+    const swapIxns = await activeSwapper.getSwapIxns(swapQuote);
+
+    // --- ATAs and Clend Instructions ---
+    const collateralTokenProgram = getTokenProgramForMint(collateralMint);
+    const debtTokenProgram = getTokenProgramForMint(debtMint);
+    // Create withdraw instruction: Withdraw the total collateral calculated by the params function
+    const withdrawIx = await this.program.clendAccountWithdraw(
+      vault,
+      vaultManager,
+      clendGroup,
+      clendAccount,
+      collateralMint,
+      collateralTokenProgram,
+      collateralToWithdraw,
+      remainingAccounts,
+    );
+
+    // if withdrawAll == true we need to make sure we withdraw emissions from both banks before withdrawing all the bank tokens
+    const emissionsIxns: web3.TransactionInstruction[] = [];
+    if (withdrawAll) {
+      // get bank data
+      const collateralBankData = activeBankData.find((b) =>
+        b.mint.equals(collateralMint),
+      );
+      if (!collateralBankData) {
+        throw new Error(
+          `Collateral bank not found: ${collateralMint.toString()}`,
+        );
+      }
+      const debtBankData = activeBankData.find((b) => b.mint.equals(debtMint));
+      if (!debtBankData) {
+        throw new Error(`Debt bank not found: ${debtMint.toString()}`);
+      }
+
+      //// collateral bank emissions
+      //if (
+      //  !collateralBankData.emissionsMint.equals(web3.PublicKey.default) &&
+      //  (collateralBankData.flags === BankFlags.LendingEmissionsActive ||
+      //    collateralBankData.flags ===
+      //      BankFlags.LendingAndBorrowingEmissionsActive)
+      //) {
+      //  const emissionsMint = collateralBankData.emissionsMint;
+      //  const emissionsMintTokenProgram = await getTokenProgramForMintFromRpc(
+      //    this.connection,
+      //    emissionsMint,
+      //  );
+      //  const withdrawEmissionsIx = await this.instructions.withdrawEmissions(
+      //    clendGroup,
+      //    clendAccount,
+      //    clendAccountData.authority,
+      //    collateralBank,
+      //    emissionsMint,
+      //    emissionsMintTokenProgram,
+      //  );
+      //  emissionsIxns.push(...withdrawEmissionsIx);
+      //}
+
+      //// debt bank emissions
+      //if (
+      //  !debtBankData.emissionsMint.equals(web3.PublicKey.default) &&
+      //  (debtBankData.flags === BankFlags.BorrowEmissionsActive ||
+      //    debtBankData.flags === BankFlags.LendingAndBorrowingEmissionsActive)
+      //) {
+      //  const emissionsMint = debtBankData.emissionsMint;
+      //  const emissionsMintTokenProgram = await getTokenProgramForMintFromRpc(
+      //    this.connection,
+      //    emissionsMint,
+      //  );
+      //  const withdrawEmissionsIx = await this.instructions.withdrawEmissions(
+      //    clendGroup,
+      //    clendAccount,
+      //    clendAccountData.authority,
+      //    debtBank,
+      //    emissionsMint,
+      //    emissionsMintTokenProgram,
+      //  );
+      //  emissionsIxns.push(...withdrawEmissionsIx);
+      //}
+    }
+
+    // Create repay instruction: Repay the debt portion using the guaranteed swap output
+    const repayIx = await this.program.clendAccountRepay(
+      vault,
+      vaultManager,
+      clendGroup,
+      clendAccount,
+      debtMint,
+      debtTokenProgram,
+      finalDebtToRepay, // Use the slippage-protected amount from the final quote
+      remainingAccounts,
+    );
+
+    // Assemble instructions
+    const ixnsWithoutFlashLoan: web3.TransactionInstruction[] = [
+      ...emissionsIxns,
+      ...withdrawIx,
+      ...swapIxns.ixns,
+      ...repayIx,
+    ];
+
+    // Flash Loan Wrapping
+    const cuIxns = 2;
+    const endIndex = new BN(
+      cuIxns + ixnsWithoutFlashLoan.length + 1 + additionalIxnCount,
+    );
+    const remainingAccountsForFlashLoan =
+      getClendAccountRemainingAccounts(activeBankData);
+
+    const { beginFlashLoanIx, endFlashLoanIx } =
+      await this.clendClient.instructions.createFlashLoanInstructions(
+        clendAccount,
+        user,
+        endIndex,
+        remainingAccountsForFlashLoan,
+      );
+
+    const instructions = [
+      beginFlashLoanIx,
+      ...ixnsWithoutFlashLoan,
+      endFlashLoanIx,
+    ];
+
+    return { ixns: instructions, luts: swapIxns.luts };
+  }
+
+  async swap(
+    vault: web3.PublicKey,
+    inputMint: web3.PublicKey,
+    outputMint: web3.PublicKey,
+    inAmount: BN,
+  ): Promise<string> {
+    const vaultAssetInReserve = getAssociatedTokenAddressSync(
+      inputMint,
+      vault,
+      true,
+      TOKEN_PROGRAM_ID,
+    );
+    const vaultAssetOutReserve = getAssociatedTokenAddressSync(
+      outputMint,
+      vault,
+      true,
+      TOKEN_PROGRAM_ID,
+    );
+
+    const quote = await this.swapper.getQuote({
+      payer: vault,
+      inputMint: inputMint,
+      inputMintDecimals: 6,
+      outputMint: outputMint,
+      outputMintDecimals: 6,
+      inputAmount: inAmount,
+      swapMode: "ExactIn",
+      slippageBps: 100,
+    });
+
+    // TODO: no setup ixns
+    const swapIxns = await this.swapper.getSwapIxns(quote);
+    const swapIx = swapIxns.ixns.find((ix) =>
+      ix.programId.equals(JUPITER_SWAP_PROGRAM_ID),
+    )!;
+    const swapRemainingAccounts: web3.AccountMeta[] = swapIx.keys.map(
+      (key) => ({
+        pubkey: key.pubkey,
+        // If the account is the vault PDA, mark it as NOT a signer for the client transaction.
+        isSigner: key.pubkey.equals(vault) ? false : key.isSigner,
+        isWritable: key.isWritable,
+      }),
+    );
+    const swapData = swapIx.data;
+
+    const ixns = await this.program.swap(
+      vault,
+      this.address(),
+      inputMint,
+      outputMint,
+      vaultAssetInReserve,
+      vaultAssetOutReserve,
+      swapData,
+      swapRemainingAccounts,
+      JUPITER_SWAP_PROGRAM_ID,
+    );
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async distributeFees(
+    vault: web3.PublicKey,
+    sharesDestinationOwner: web3.PublicKey,
+  ): Promise<string> {
+    // fetch vault data
+    const vaultData = await this.getVault(vault);
+    const manager = vaultData.manager;
+    const shares = vaultData.sharesMint;
+
+    const ixns = await this.program.distributeFees(
+      vault,
+      manager,
+      shares,
+      sharesDestinationOwner,
+    );
+
+    const txSig = await this.send(ixns);
+
+    return txSig;
+  }
+
+  async send(
+    ixns: web3.TransactionInstruction[],
+    additionalSigners: web3.Signer[] = [],
+  ): Promise<string> {
+    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+    const msg = new web3.TransactionMessage({
+      payerKey: this.address(),
+      recentBlockhash: blockhash,
+      instructions: ixns,
+    }).compileToV0Message();
+
+    const tx = new web3.VersionedTransaction(msg);
+
+    const signedTx =
+      await this.program.program.provider.wallet!.signTransaction(tx);
+    signedTx.sign(additionalSigners);
+
+    try {
+      const txSig = await this.connection.sendRawTransaction(
+        signedTx.serialize(),
+        {
+          skipPreflight: this.skipPreflight,
+        },
+      );
+
+      // will throw an error if not found or tx errored
+      await this.confirmTx(txSig);
+
+      return txSig;
+    } catch (e) {
+      if (e instanceof web3.SendTransactionError) {
+        throw new Error(`tx failed: ${e}`);
+      }
+      throw e;
+    }
+  }
+
+  async confirmTx(txSig: string): Promise<void> {
+    const maxAttempts = 90;
+    const sleepDurationMs = 1000; // 1 sec
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const txResult = await this.connection.getSignatureStatuses([txSig], {
+        searchTransactionHistory: false,
+      });
+
+      if (txResult.value.length > 0 && txResult.value[0] !== null) {
+        const txSigResult = txResult.value[0];
+        if (txSigResult.err !== null) {
+          throw new Error(
+            `tx returned an error: ${txSigResult.err.toString()}`,
+          );
+        }
+        return; // Transaction confirmed successfully
+      }
+
+      if (attempt < maxAttempts - 1) {
+        // sleep before next attempt
+        await new Promise((resolve) => setTimeout(resolve, sleepDurationMs));
+      }
+    }
+
+    // If we've exhausted all attempts, throw the error
+    throw new Error(`tx sig ${txSig} not found after ${maxAttempts} attempts`);
+  }
+}
+
+export async function buildEquityRemainingAccounts(
+  vaultData: Vault,
+  clendClient: ClendClient,
+): Promise<AccountMeta[]> {
+  // gather all asset mints, oracles, reserves, and clend accounts
+  const assetMints: web3.PublicKey[] = vaultData.assets.map(
+    (a) => a.mint.address,
+  );
+  const assetOracles: web3.PublicKey[] = vaultData.assets.map((a) => a.oracle);
+  const assetReserves: web3.PublicKey[] = vaultData.assets.map(
+    (a) => a.reserve.address,
+  );
+  const clendAccounts: web3.PublicKey[] = vaultData.clendAccounts.map(
+    (ca) => ca.address,
+  );
+
+  const base: AccountMeta[] = [
+    // mints
+    ...assetMints.map((a) => ({
+      pubkey: a,
+      isSigner: false,
+      isWritable: false,
+    })),
+    // oracles
+    ...assetOracles.map((a) => ({
+      pubkey: a,
+      isSigner: false,
+      isWritable: false,
+    })),
+    // reserves
+    ...assetReserves.map((a) => ({
+      pubkey: a,
+      isSigner: false,
+      isWritable: false,
+    })),
+    // clend account addrs
+    ...clendAccounts.map((ca) => ({
+      pubkey: ca,
+      isSigner: false,
+      isWritable: false,
+    })),
+  ];
+
+  // include each clend account's active banks + their oracles
+  const bankAndOracleMetas: AccountMeta[] = [];
+  for (const ca of clendAccounts) {
+    const state = await clendClient.getClendAccount(ca);
+    if (!state) {
+      throw new Error(`Clend account not found: ${ca.toString()}`);
+    }
+    const activeBanks = getClendAccountActiveBanks(state);
+
+    const activeBankState: Bank[] = [];
+    for (const bank of activeBanks) {
+      const bankData = await clendClient.getBank(bank);
+      activeBankState.push(bankData);
+    }
+    const rem = getClendAccountRemainingAccounts(activeBankState);
+    bankAndOracleMetas.push(...rem);
+  }
+
+  // de-duplicate metas by pubkey, preserving writability where needed
+  const byPk = new Map<string, AccountMeta>();
+  const absorb = (m: AccountMeta) => {
+    const k = m.pubkey.toBase58();
+    const prev = byPk.get(k);
+    if (!prev) byPk.set(k, m);
+    else
+      byPk.set(k, {
+        pubkey: m.pubkey,
+        isSigner: prev.isSigner || m.isSigner,
+        isWritable: prev.isWritable || m.isWritable,
+      });
+  };
+  [...base, ...bankAndOracleMetas].forEach(absorb);
+
+  const remAccounts = [...byPk.values()];
+  return remAccounts;
+}