@carrot-protocol/clend-vaults-rpc 0.0.2 → 0.0.3-pub2-dev-be4bd59

package/dist/rpc.js

@@ -0,0 +1,685 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClendVaultsClient = void 0;
+exports.buildEquityRemainingAccounts = buildEquityRemainingAccounts;
+// rpc.ts
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const decimal_js_1 = require("decimal.js");
+const program_1 = require("./program");
+const addresses_1 = require("./addresses");
+const clend_rpc_1 = require("@carrot-protocol/clend-rpc");
+const state_1 = require("./state");
+const swapper_1 = require("./swapper");
+const math_1 = require("./math");
+class ClendVaultsClient {
+    constructor(provider, skipPreflight = false, swapperOverride) {
+        this.connection = provider.connection;
+        this.program = new program_1.ClendVaultsProgram(provider);
+        this.skipPreflight = skipPreflight;
+        this.clendClient = new clend_rpc_1.ClendClient(provider.connection, provider.wallet, skipPreflight, 0);
+        this.swapper =
+            swapperOverride || new swapper_1.ClendVaultsJupSwapper(this.connection);
+    }
+    address() {
+        return this.program.program.provider.publicKey;
+    }
+    async getVault(vault) {
+        const vaultAccountInfo = await this.connection.getAccountInfo(vault);
+        if (!vaultAccountInfo) {
+            throw new Error(`Vault account not found: ${vault.toString()}`);
+        }
+        return (0, state_1.parseVaultAccount)(vault, vaultAccountInfo, this.connection);
+    }
+    async getVaultEquity(vault) {
+        let vaultEquity = 0;
+        const clendAccountEquity = [];
+        // 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 = (0, math_1.calculateLendingAccountEquity)(clendAccountData.lendingAccount);
+            clendAccountEquity.push({
+                address: clendAccount.address,
+                equity: lendingAccountEquity,
+            });
+            vaultEquity += lendingAccountEquity;
+        }
+        // calculate equity for each reserve
+        const reserveEquity = [];
+        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, managementFeeBps) {
+        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, assetMint, assetOracle, addAssetArgs) {
+        const ixns = await this.program.addAsset(vault, this.address(), assetMint, assetOracle, spl_token_1.TOKEN_PROGRAM_ID, addAssetArgs);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async addClendAccount(vault, clendGroup) {
+        const clendAccount = anchor_1.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, newManager) {
+        return this.program.updateVaultManager(vault, this.address(), newManager);
+    }
+    async issue(vault, assetMint, amount) {
+        const ixns = await this.prepareIssueIxns(this.address(), vault, assetMint, amount);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async prepareIssueIxns(user, vault, assetMint, amount) {
+        // 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, spl_token_1.TOKEN_PROGRAM_ID, spl_token_1.TOKEN_2022_PROGRAM_ID, remainingAccounts);
+        return ixns;
+    }
+    async redeem(vault, assetMint, sharesAmount) {
+        const ixns = await this.prepareRedeemIxns(this.address(), vault, assetMint, sharesAmount);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async prepareRedeemIxns(user, vault, assetMint, amount) {
+        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, spl_token_1.TOKEN_PROGRAM_ID, spl_token_1.TOKEN_2022_PROGRAM_ID, remainingAccounts);
+    }
+    async clendAccountDeposit(vault, clendAccount, assetMint, amount) {
+        // 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 = (0, clend_rpc_1.getClendAccountRemainingAccounts)([]);
+        const ixns = await this.program.clendAccountDeposit(vault, this.address(), clendAccountData.group, clendAccount, assetMint, spl_token_1.TOKEN_PROGRAM_ID, amount, assetData.reserve.address, ra);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async clendAccountWithdraw(vault, clendAccount, assetMint, amount) {
+        // 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 = (0, clend_rpc_1.getClendAccountActiveBanks)(clendAccountData);
+        const activeBankData = [];
+        for (const bank of clendAccountActiveBanks) {
+            const bankData = await this.clendClient.getBank(bank);
+            activeBankData.push(bankData);
+        }
+        const ra = (0, clend_rpc_1.getClendAccountRemainingAccounts)(activeBankData);
+        const ixns = await this.program.clendAccountWithdraw(vault, this.address(), clendAccountData.group, clendAccount, assetMint, spl_token_1.TOKEN_PROGRAM_ID, amount, ra);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async clendAccountRepay(vault, clendAccount, assetMint, amount) {
+        const clendAccountData = await this.clendClient.getClendAccount(clendAccount);
+        if (!clendAccountData) {
+            throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+        }
+        const ra = (0, clend_rpc_1.getClendAccountRemainingAccounts)([]);
+        const ixns = await this.program.clendAccountRepay(vault, this.address(), clendAccountData.group, clendAccount, assetMint, spl_token_1.TOKEN_PROGRAM_ID, amount, ra);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async clendAccountBorrow(vault, clendAccount, assetMint, amount) {
+        const clendAccountData = await this.clendClient.getClendAccount(clendAccount);
+        if (!clendAccountData) {
+            throw new Error(`Clend account not found: ${clendAccount.toString()}`);
+        }
+        // fetch active banks
+        const clendAccountActiveBanks = (0, clend_rpc_1.getClendAccountActiveBanks)(clendAccountData);
+        // add target bank if not already in list
+        // this would be the case for a first time borrow
+        const targetBank = (0, clend_rpc_1.getBankPda)(clendAccountData.group, assetMint);
+        const alreadyInBankList = clendAccountActiveBanks.some((c) => c.equals(targetBank));
+        if (!alreadyInBankList) {
+            clendAccountActiveBanks.push(targetBank);
+        }
+        const activeBankData = [];
+        for (const bank of clendAccountActiveBanks) {
+            const bankData = await this.clendClient.getBank(bank);
+            activeBankData.push(bankData);
+        }
+        const ra = (0, clend_rpc_1.getClendAccountRemainingAccounts)(activeBankData);
+        const ixns = await this.program.clendAccountBorrow(vault, this.address(), clendAccountData.group, clendAccount, assetMint, spl_token_1.TOKEN_PROGRAM_ID, amount, ra);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async clendAccountClaimEmissions(vault, clendGroup, clendAccount, bank, assetMint, emissionsMint) {
+        const emissionsVault = (0, clend_rpc_1.getBankLiquidityVaultPda)(bank);
+        const emissionsAuthority = (0, clend_rpc_1.getBankLiquidityVaultAuthorityPda)(bank);
+        // destination is an ATA owned by the vault PDA
+        const destinationAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(emissionsMint, vault, true, spl_token_1.TOKEN_PROGRAM_ID);
+        return this.program.clendAccountClaimEmissions(vault, this.address(), clendGroup, clendAccount, bank, assetMint, emissionsMint, destinationAccount, spl_token_1.TOKEN_PROGRAM_ID, emissionsVault, emissionsAuthority, clend_rpc_1.CLEND_PROGRAM_ID);
+    }
+    // adjust the leverage of the clend account
+    async clendAccountAdjustLeverage(clendAccount, collateralMint, debtMint, targetLeverage, slippageBps) {
+        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, vault, clendAccount, outputAssetMint, collateralMint, debtMint, totalSharesToRedeem, sharesToRedeemFromClendAccount, slippageBps) {
+        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 = (0, math_1.amountToUi)(vaultState.sharesSupply, vaultState.sharesDecimals);
+        const sharesToRedeemFromClendAccountUi = (0, math_1.amountToUi)(sharesToRedeemFromClendAccount, vaultState.sharesDecimals);
+        const vaultNav = (0, math_1.calculateVaultNav)(vaultEquity.vaultEquity, sharesSupplyUi);
+        // TODO: will need to add fees to this
+        const desiredOutputAmount = (0, math_1.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 = 0;
+        let cuIxCount = 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;
+        let collateralToWithdraw;
+        let debtBankData;
+        let collateralBankData;
+        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 = [];
+        let luts = [];
+        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 = [...ixns, ...redeemIxns];
+        return { ixns: allIxns, luts };
+    }
+    async getWithdrawLeverageCollateralIxns(vault, vaultManager, user, clendGroup, clendAccount, collateralMint, debtMint, collateralDecimals, debtDecimals, withdrawAll, collateralToWithdraw, desiredNetCollateralToReceive, debtToRepay, slippageBps, additionalIxnCount, swapperOverride) {
+        // 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 = (0, clend_rpc_1.getClendAccountActiveBanks)(clendAccountData);
+        const activeBankData = await this.clendClient.getBanks(activeBanks);
+        const remainingAccounts = (0, clend_rpc_1.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 = (0, math_1.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 = (0, math_1.amountToUi)(nominalQuote.otherAmountThreshold, debtDecimals);
+            // Step 2: Estimate the ideal collateral needed to cover the debt.
+            const debtToRepayUi = new decimal_js_1.Decimal((0, math_1.amountToUi)(debtToRepay, debtDecimals).toString());
+            const collateralToSwapUi_ideal = debtToRepayUi.div(outAmountUi);
+            const collateralToSwap_ideal = (0, math_1.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 (0, clend_rpc_1.getTokenProgramForMintFromRpc)(this.connection, collateralMint);
+        const debtTokenProgram = await (0, clend_rpc_1.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 = [];
+        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 = [
+            ...emissionsIxns,
+            ...withdrawIx,
+            ...swapIxns.ixns,
+            ...repayIx,
+        ];
+        const cuIxns = 2;
+        const endIndex = new anchor_1.BN(cuIxns + ixnsWithoutFlashLoan.length + 1 + additionalIxnCount);
+        const remainingAccountsForFlashLoan = (0, clend_rpc_1.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, vaultManager, user, clendGroup, clendAccount, collateralMint, debtMint, collateralDecimals, debtDecimals, withdrawAll, debtToRepay, collateralToWithdraw, slippageBps, additionalIxnCount, swapperOverride) {
+        // 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 = (0, clend_rpc_1.getClendAccountActiveBanks)(clendAccountData);
+        const activeBankData = await this.clendClient.getBanks(activeBanks);
+        const remainingAccounts = (0, clend_rpc_1.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 = anchor_1.BN.min(debtToRepay, minDebtReceivedFromSwap);
+        // Get Swap Instructions from the swapper
+        const swapIxns = await activeSwapper.getSwapIxns(swapQuote);
+        // --- ATAs and Clend Instructions ---
+        const collateralTokenProgram = (0, clend_rpc_1.getTokenProgramForMint)(collateralMint);
+        const debtTokenProgram = (0, clend_rpc_1.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 = [];
+        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 = [
+            ...emissionsIxns,
+            ...withdrawIx,
+            ...swapIxns.ixns,
+            ...repayIx,
+        ];
+        // Flash Loan Wrapping
+        const cuIxns = 2;
+        const endIndex = new anchor_1.BN(cuIxns + ixnsWithoutFlashLoan.length + 1 + additionalIxnCount);
+        const remainingAccountsForFlashLoan = (0, clend_rpc_1.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, inputMint, outputMint, inAmount) {
+        const vaultAssetInReserve = (0, spl_token_1.getAssociatedTokenAddressSync)(inputMint, vault, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const vaultAssetOutReserve = (0, spl_token_1.getAssociatedTokenAddressSync)(outputMint, vault, true, spl_token_1.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(addresses_1.JUPITER_SWAP_PROGRAM_ID));
+        const swapRemainingAccounts = 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, addresses_1.JUPITER_SWAP_PROGRAM_ID);
+        const txSig = await this.send(ixns);
+        return txSig;
+    }
+    async distributeFees(vault, sharesDestinationOwner) {
+        // 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, additionalSigners = []) {
+        const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+        const msg = new anchor_1.web3.TransactionMessage({
+            payerKey: this.address(),
+            recentBlockhash: blockhash,
+            instructions: ixns,
+        }).compileToV0Message();
+        const tx = new anchor_1.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 anchor_1.web3.SendTransactionError) {
+                throw new Error(`tx failed: ${e}`);
+            }
+            throw e;
+        }
+    }
+    async confirmTx(txSig) {
+        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`);
+    }
+}
+exports.ClendVaultsClient = ClendVaultsClient;
+async function buildEquityRemainingAccounts(vaultData, clendClient) {
+    // gather all asset mints, oracles, reserves, and clend accounts
+    const assetMints = vaultData.assets.map((a) => a.mint.address);
+    const assetOracles = vaultData.assets.map((a) => a.oracle);
+    const assetReserves = vaultData.assets.map((a) => a.reserve.address);
+    const clendAccounts = vaultData.clendAccounts.map((ca) => ca.address);
+    const base = [
+        // 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 = [];
+    for (const ca of clendAccounts) {
+        const state = await clendClient.getClendAccount(ca);
+        if (!state) {
+            throw new Error(`Clend account not found: ${ca.toString()}`);
+        }
+        const activeBanks = (0, clend_rpc_1.getClendAccountActiveBanks)(state);
+        const activeBankState = [];
+        for (const bank of activeBanks) {
+            const bankData = await clendClient.getBank(bank);
+            activeBankState.push(bankData);
+        }
+        const rem = (0, clend_rpc_1.getClendAccountRemainingAccounts)(activeBankState);
+        bankAndOracleMetas.push(...rem);
+    }
+    // de-duplicate metas by pubkey, preserving writability where needed
+    const byPk = new Map();
+    const absorb = (m) => {
+        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;
+}
+//# sourceMappingURL=rpc.js.map