@kamino-finance/klend-sdk 3.2.25 → 4.0.0

package/dist/classes/vault.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -60,6 +51,10 @@ const SHARES_SEEDS = 'shares';
  * KaminoVaultClient is a class that provides a high-level interface to interact with the Kamino Vault program.
  */
 class KaminoVaultClient {
+    _connection;
+    _kaminoVaultProgramId;
+    _kaminoLendProgramId;
+    recentSlotDurationMs;
     constructor(connection, kaminoVaultprogramId, kaminoLendProgramId, recentSlotDurationMs) {
         this._connection = connection;
         this._kaminoVaultProgramId = kaminoVaultprogramId ? kaminoVaultprogramId : exports.kaminoVaultId;
@@ -78,35 +73,33 @@ class KaminoVaultClient {
      * @returns vault - keypair, should be used to sign the transaction which creates the vault account
      * @returns ixns - an array of instructions to create the vault
      */
-    createVaultIxs(vaultConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = web3_js_1.Keypair.generate();
-            const size = accounts_1.VaultState.layout.span + 8;
-            const createVaultIx = web3_js_1.SystemProgram.createAccount({
-                fromPubkey: vaultConfig.admin,
-                newAccountPubkey: vaultState.publicKey,
-                lamports: yield this._connection.getMinimumBalanceForRentExemption(size),
-                space: size,
-                programId: this._kaminoVaultProgramId,
-            });
-            const tokenVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(TOKEN_VAULT_SEED), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
-            const baseVaultAuthority = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(BASE_VAULT_AUTHORITY_SEED), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
-            const sharesMint = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SHARES_SEEDS), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
-            const initVaultAccounts = {
-                adminAuthority: vaultConfig.admin,
-                vaultState: vaultState.publicKey,
-                tokenMint: vaultConfig.tokenMint,
-                tokenVault,
-                baseVaultAuthority,
-                sharesMint,
-                systemProgram: web3_js_1.SystemProgram.programId,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                tokenProgram: vaultConfig.tokenMintProgramId,
-            };
-            const initVaultIx = (0, instructions_1.initVault)(initVaultAccounts, this._kaminoVaultProgramId);
-            // TODO: Add logic to update vault based on vaultConfig
-            return { vault: vaultState, ixns: [createVaultIx, initVaultIx] };
+    async createVaultIxs(vaultConfig) {
+        const vaultState = web3_js_1.Keypair.generate();
+        const size = accounts_1.VaultState.layout.span + 8;
+        const createVaultIx = web3_js_1.SystemProgram.createAccount({
+            fromPubkey: vaultConfig.admin,
+            newAccountPubkey: vaultState.publicKey,
+            lamports: await this._connection.getMinimumBalanceForRentExemption(size),
+            space: size,
+            programId: this._kaminoVaultProgramId,
         });
+        const tokenVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(TOKEN_VAULT_SEED), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
+        const baseVaultAuthority = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(BASE_VAULT_AUTHORITY_SEED), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
+        const sharesMint = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SHARES_SEEDS), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
+        const initVaultAccounts = {
+            adminAuthority: vaultConfig.admin,
+            vaultState: vaultState.publicKey,
+            tokenMint: vaultConfig.tokenMint,
+            tokenVault,
+            baseVaultAuthority,
+            sharesMint,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            tokenProgram: vaultConfig.tokenMintProgramId,
+        };
+        const initVaultIx = (0, instructions_1.initVault)(initVaultAccounts, this._kaminoVaultProgramId);
+        // TODO: Add logic to update vault based on vaultConfig
+        return { vault: vaultState, ixns: [createVaultIx, initVaultIx] };
     }
     /**
      * This method updates the vault reserve allocation cofnig for an exiting vault reserve, or adds a new reserve to the vault if it does not exist.
@@ -114,28 +107,26 @@ class KaminoVaultClient {
      * @param reserveAllocationConfig - new reserve allocation config
      * @returns - a list of instructions
      */
-    updateReserveAllocationIxs(vault, reserveAllocationConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this.getConnection());
-            const reserveState = reserveAllocationConfig.getReserveState();
-            const cTokenVault = getCTokenVaultPda(reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
-            const updateReserveAllocationAccounts = {
-                adminAuthority: vaultState.adminAuthority,
-                vaultState: vault.address,
-                baseVaultAuthority: vaultState.baseVaultAuthority,
-                reserveCollateralMint: reserveState.collateral.mintPubkey,
-                reserve: reserveAllocationConfig.getReserveAddress(),
-                ctokenVault: cTokenVault,
-                systemProgram: web3_js_1.SystemProgram.programId,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            };
-            const updateReserveAllocationArgs = {
-                weight: new anchor_1.BN(reserveAllocationConfig.targetAllocationWeight),
-                cap: new anchor_1.BN(reserveAllocationConfig.getAllocationCapLamports().floor().toString()),
-            };
-            return (0, instructions_1.updateReserveAllocation)(updateReserveAllocationArgs, updateReserveAllocationAccounts, this._kaminoVaultProgramId);
-        });
+    async updateReserveAllocationIxs(vault, reserveAllocationConfig) {
+        const vaultState = await vault.getState(this.getConnection());
+        const reserveState = reserveAllocationConfig.getReserveState();
+        const cTokenVault = getCTokenVaultPda(reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
+        const updateReserveAllocationAccounts = {
+            adminAuthority: vaultState.adminAuthority,
+            vaultState: vault.address,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            reserveCollateralMint: reserveState.collateral.mintPubkey,
+            reserve: reserveAllocationConfig.getReserveAddress(),
+            ctokenVault: cTokenVault,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        const updateReserveAllocationArgs = {
+            weight: new anchor_1.BN(reserveAllocationConfig.targetAllocationWeight),
+            cap: new anchor_1.BN(reserveAllocationConfig.getAllocationCapLamports().floor().toString()),
+        };
+        return (0, instructions_1.updateReserveAllocation)(updateReserveAllocationArgs, updateReserveAllocationAccounts, this._kaminoVaultProgramId);
     }
     /**
      * This function creates instructions to deposit into a vault. It will also create ATA creation instructions for the vault shares that the user receives in return
@@ -144,45 +135,43 @@ class KaminoVaultClient {
      * @param tokenAmount - token amount to be deposited, in decimals (will be converted in lamports)
      * @returns - an array of instructions to be used to be executed
      */
-    depositIxs(user, vault, tokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const userTokenAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user);
-            const createAtasIxns = [];
-            const closeAtasIxns = [];
-            if (vaultState.tokenMint.equals(lib_1.WRAPPED_SOL_MINT)) {
-                const { atas: wsolAta, createAtasIxns: createWsolAtaIxns, closeAtasIxns: closeWsolAtaIxns, } = yield (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [lib_1.WRAPPED_SOL_MINT], [spl_token_1.TOKEN_PROGRAM_ID]);
-                createAtasIxns.push(...createWsolAtaIxns);
-                const depositWsolixn = (0, lib_1.getDepositWsolIxns)(user, wsolAta[0], (0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil());
-                createAtasIxns.push(...depositWsolixn);
-                closeAtasIxns.push(...closeWsolAtaIxns);
-            }
-            const { atas, createAtasIxns: createSharesAtaIxns } = yield (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [vaultState.sharesMint], [spl_token_1.TOKEN_PROGRAM_ID]);
-            createAtasIxns.push(...createSharesAtaIxns);
-            const userSharesAta = atas[0];
-            const depoistAccounts = {
-                user: user,
-                vaultState: vault.address,
-                tokenVault: vaultState.tokenVault,
-                tokenMint: vaultState.tokenMint,
-                baseVaultAuthority: vaultState.baseVaultAuthority,
-                sharesMint: vaultState.sharesMint,
-                tokenAta: userTokenAta,
-                userSharesAta: userSharesAta,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
-            };
-            const depositArgs = {
-                maxAmount: new anchor_1.BN((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).toString()),
-            };
-            const depositIx = (0, deposit_1.deposit)(depositArgs, depoistAccounts, this._kaminoVaultProgramId);
-            const vaultReserves = this.getVaultReserves(vaultState);
-            const vaultReservesAccountMetas = vaultReserves.map((reserve) => {
-                return { pubkey: reserve, isSigner: false, isWritable: false };
-            });
-            depositIx.keys = depositIx.keys.concat(vaultReservesAccountMetas);
-            return [...createAtasIxns, depositIx, ...closeAtasIxns];
+    async depositIxs(user, vault, tokenAmount) {
+        const vaultState = await vault.getState(this._connection);
+        const userTokenAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user);
+        const createAtasIxns = [];
+        const closeAtasIxns = [];
+        if (vaultState.tokenMint.equals(lib_1.WRAPPED_SOL_MINT)) {
+            const { atas: wsolAta, createAtasIxns: createWsolAtaIxns, closeAtasIxns: closeWsolAtaIxns, } = await (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [lib_1.WRAPPED_SOL_MINT], [spl_token_1.TOKEN_PROGRAM_ID]);
+            createAtasIxns.push(...createWsolAtaIxns);
+            const depositWsolixn = (0, lib_1.getDepositWsolIxns)(user, wsolAta[0], (0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil());
+            createAtasIxns.push(...depositWsolixn);
+            closeAtasIxns.push(...closeWsolAtaIxns);
+        }
+        const { atas, createAtasIxns: createSharesAtaIxns } = await (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [vaultState.sharesMint], [spl_token_1.TOKEN_PROGRAM_ID]);
+        createAtasIxns.push(...createSharesAtaIxns);
+        const userSharesAta = atas[0];
+        const depoistAccounts = {
+            user: user,
+            vaultState: vault.address,
+            tokenVault: vaultState.tokenVault,
+            tokenMint: vaultState.tokenMint,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            sharesMint: vaultState.sharesMint,
+            tokenAta: userTokenAta,
+            userSharesAta: userSharesAta,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        };
+        const depositArgs = {
+            maxAmount: new anchor_1.BN((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).toString()),
+        };
+        const depositIx = (0, deposit_1.deposit)(depositArgs, depoistAccounts, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        const vaultReservesAccountMetas = vaultReserves.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: false };
         });
+        depositIx.keys = depositIx.keys.concat(vaultReservesAccountMetas);
+        return [...createAtasIxns, depositIx, ...closeAtasIxns];
     }
     /**
      * This function will return the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
@@ -192,75 +181,71 @@ class KaminoVaultClient {
      * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
      * @returns an array of instructions to be executed
      */
-    withdrawIxs(user, vault, shareAmount, slot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
-            const { atas, createAtasIxns } = yield (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [vaultState.tokenMint], [spl_token_1.TOKEN_PROGRAM_ID]);
-            const userTokenAta = atas[0];
-            const tokensToWithdraw = shareAmount.div(yield this.getTokensPerShareSingleVault(vault, slot));
-            let tokenLeftToWithdraw = tokensToWithdraw;
-            tokenLeftToWithdraw = tokenLeftToWithdraw.sub(new decimal_js_1.default(vaultState.tokenAvailable.toString()));
-            const reservesToWithdraw = [];
-            const amountToWithdraw = [];
-            amountToWithdraw.push(new decimal_js_1.default(vaultState.tokenAvailable.toString()));
-            if (tokenLeftToWithdraw.lte(0)) {
-                // Availabe enough to withdraw all - using first reserve as it does not matter
-                reservesToWithdraw.push(vaultState.vaultAllocationStrategy[0].reserve);
+    async withdrawIxs(user, vault, shareAmount, slot) {
+        const vaultState = await vault.getState(this._connection);
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const { atas, createAtasIxns } = await (0, lib_1.getAtasWithCreateIxnsIfMissing)(this._connection, user, [vaultState.tokenMint], [spl_token_1.TOKEN_PROGRAM_ID]);
+        const userTokenAta = atas[0];
+        const tokensToWithdraw = shareAmount.div(await this.getTokensPerShareSingleVault(vault, slot));
+        let tokenLeftToWithdraw = tokensToWithdraw;
+        tokenLeftToWithdraw = tokenLeftToWithdraw.sub(new decimal_js_1.default(vaultState.tokenAvailable.toString()));
+        const reservesToWithdraw = [];
+        const amountToWithdraw = [];
+        amountToWithdraw.push(new decimal_js_1.default(vaultState.tokenAvailable.toString()));
+        if (tokenLeftToWithdraw.lte(0)) {
+            // Availabe enough to withdraw all - using first reserve as it does not matter
+            reservesToWithdraw.push(vaultState.vaultAllocationStrategy[0].reserve);
+        }
+        else {
+            // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
+            const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(vault, slot);
+            // sort
+            const reserveAllocationAvailableLiquidityToWithdrawSorted = new lib_1.PubkeyHashMap([...reserveAllocationAvailableLiquidityToWithdraw.entries()].sort((a, b) => b[1].sub(a[1]).toNumber()));
+            reserveAllocationAvailableLiquidityToWithdrawSorted.forEach((availableLiquidityToWithdraw, key) => {
+                if (tokenLeftToWithdraw.gt(0)) {
+                    reservesToWithdraw.push(key);
+                    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableLiquidityToWithdraw);
+                    amountToWithdraw.push(decimal_js_1.default.min(tokenLeftToWithdraw, availableLiquidityToWithdraw));
+                }
+            });
+        }
+        const reserveStates = await lib_1.Reserve.fetchMultiple(this._connection, reservesToWithdraw, this._kaminoLendProgramId);
+        const withdrawIxns = await Promise.all(reservesToWithdraw.map(async (reserve, index) => {
+            if (reserveStates[index] === null) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
             }
-            else {
-                // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
-                const reserveAllocationAvailableLiquidityToWithdraw = yield this.getReserveAllocationAvailableLiquidityToWithdraw(vault, slot);
-                // sort
-                const reserveAllocationAvailableLiquidityToWithdrawSorted = new lib_1.PubkeyHashMap([...reserveAllocationAvailableLiquidityToWithdraw.entries()].sort((a, b) => b[1].sub(a[1]).toNumber()));
-                reserveAllocationAvailableLiquidityToWithdrawSorted.forEach((availableLiquidityToWithdraw, key) => {
-                    if (tokenLeftToWithdraw.gt(0)) {
-                        reservesToWithdraw.push(key);
-                        tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableLiquidityToWithdraw);
-                        amountToWithdraw.push(decimal_js_1.default.min(tokenLeftToWithdraw, availableLiquidityToWithdraw));
-                    }
-                });
+            const reserveState = reserveStates[index];
+            const market = reserveState.lendingMarket;
+            const marketState = await lib_1.LendingMarket.fetch(this._connection, market, this._kaminoLendProgramId);
+            if (marketState === null) {
+                throw new Error(`Market ${market.toBase58()} not found`);
             }
-            const reserveStates = yield lib_1.Reserve.fetchMultiple(this._connection, reservesToWithdraw, this._kaminoLendProgramId);
-            const withdrawIxns = yield Promise.all(reservesToWithdraw.map((reserve, index) => __awaiter(this, void 0, void 0, function* () {
-                if (reserveStates[index] === null) {
-                    throw new Error(`Reserve ${reserve.toBase58()} not found`);
-                }
-                const reserveState = reserveStates[index];
-                const market = reserveState.lendingMarket;
-                const marketState = yield lib_1.LendingMarket.fetch(this._connection, market, this._kaminoLendProgramId);
-                if (marketState === null) {
-                    throw new Error(`Market ${market.toBase58()} not found`);
-                }
-                const marketWithAddress = {
-                    address: market,
-                    state: marketState,
-                };
-                return this.withdrawIxn(user, vault, vaultState, marketWithAddress, { address: reserve, state: reserveState }, userSharesAta, userTokenAta, amountToWithdraw[index]);
-            })));
-            return [...createAtasIxns, ...withdrawIxns];
-        });
+            const marketWithAddress = {
+                address: market,
+                state: marketState,
+            };
+            return this.withdrawIxn(user, vault, vaultState, marketWithAddress, { address: reserve, state: reserveState }, userSharesAta, userTokenAta, amountToWithdraw[index]);
+        }));
+        return [...createAtasIxns, ...withdrawIxns];
     }
     /**
      * This will trigger invest by balancing, based on weights, the reserve allocations of the vault. It can either withdraw or deposit into reserves to balance them. This is a function that should be cranked
      * @param kaminoVault - vault to invest from
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
-    investAllReservesIxs(vault) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //TODO: Order invest ixns by - invest that removes first, then invest that adds
-            const vaultState = yield vault.getState(this._connection);
-            const vaultReserves = this.getVaultReserves(vaultState);
-            const investIxns = [];
-            for (const reserve of vaultReserves) {
-                const reserveState = yield lib_1.Reserve.fetch(this._connection, reserve, this._kaminoLendProgramId);
-                if (reserveState === null) {
-                    throw new Error(`Reserve ${reserve.toBase58()} not found`);
-                }
-                investIxns.push(yield this.investSingleReserveIxs(vault, { address: reserve, state: reserveState }));
+    async investAllReservesIxs(vault) {
+        //TODO: Order invest ixns by - invest that removes first, then invest that adds
+        const vaultState = await vault.getState(this._connection);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        const investIxns = [];
+        for (const reserve of vaultReserves) {
+            const reserveState = await lib_1.Reserve.fetch(this._connection, reserve, this._kaminoLendProgramId);
+            if (reserveState === null) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
             }
-            return investIxns;
-        });
+            investIxns.push(await this.investSingleReserveIxs(vault, { address: reserve, state: reserveState }));
+        }
+        return investIxns;
     }
     /**
      * This will trigger invest by balancing, based on weights, the reserve allocation of the vault. It can either withdraw or deposit into the given reserve to balance it
@@ -268,35 +253,33 @@ class KaminoVaultClient {
      * @param reserve - reserve to invest into or disinvest from
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
-    investSingleReserveIxs(vault, reserve) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const cTokenVault = getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId);
-            const lendingMarketAuth = (0, seeds_1.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
-            const investAccounts = {
-                adminAuthority: vaultState.adminAuthority,
-                vaultState: vault.address,
-                tokenVault: vaultState.tokenVault,
-                baseVaultAuthority: vaultState.baseVaultAuthority,
-                ctokenVault: cTokenVault,
-                reserve: reserve.address,
-                /** CPI accounts */
-                lendingMarket: reserve.state.lendingMarket,
-                lendingMarketAuthority: lendingMarketAuth,
-                reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
-                reserveCollateralMint: reserve.state.collateral.mintPubkey,
-                klendProgram: this._kaminoLendProgramId,
-                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            };
-            const investIx = (0, instructions_1.invest)(investAccounts, this._kaminoVaultProgramId);
-            const vaultReserves = this.getVaultReserves(vaultState);
-            const vaultReservesAccountMetas = vaultReserves.map((reserve) => {
-                return { pubkey: reserve, isSigner: false, isWritable: true };
-            });
-            investIx.keys = investIx.keys.concat(vaultReservesAccountMetas);
-            return investIx;
+    async investSingleReserveIxs(vault, reserve) {
+        const vaultState = await vault.getState(this._connection);
+        const cTokenVault = getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId);
+        const lendingMarketAuth = (0, seeds_1.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
+        const investAccounts = {
+            adminAuthority: vaultState.adminAuthority,
+            vaultState: vault.address,
+            tokenVault: vaultState.tokenVault,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            ctokenVault: cTokenVault,
+            reserve: reserve.address,
+            /** CPI accounts */
+            lendingMarket: reserve.state.lendingMarket,
+            lendingMarketAuthority: lendingMarketAuth,
+            reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
+            reserveCollateralMint: reserve.state.collateral.mintPubkey,
+            klendProgram: this._kaminoLendProgramId,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        const investIx = (0, instructions_1.invest)(investAccounts, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        const vaultReservesAccountMetas = vaultReserves.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: true };
         });
+        investIx.keys = investIx.keys.concat(vaultReservesAccountMetas);
+        return investIx;
     }
     withdrawIxn(user, vault, vaultState, marketWithAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports) {
         const lendingMarketAuth = (0, seeds_1.lendingMarketAuthPda)(marketWithAddress.address, this._kaminoLendProgramId)[0];
@@ -337,17 +320,15 @@ class KaminoVaultClient {
      * @param vault - vault to calculate shares balance for
      * @returns - user share balance in decimal (not lamports)
      */
-    getUserSharesBalanceSingleVault(user, vault) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
-            const userSharesAccountInfo = yield this._connection.getAccountInfo(userSharesAta);
-            if (!userSharesAccountInfo) {
-                return new decimal_js_1.default(0);
-            }
-            const userSharesAccount = (0, spl_token_1.unpackAccount)(userSharesAta, userSharesAccountInfo);
-            return new decimal_js_1.default(new decimal_js_1.default(userSharesAccount.amount.toString()).toNumber()).div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toNumber()));
-        });
+    async getUserSharesBalanceSingleVault(user, vault) {
+        const vaultState = await vault.getState(this._connection);
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const userSharesAccountInfo = await this._connection.getAccountInfo(userSharesAta);
+        if (!userSharesAccountInfo) {
+            return new decimal_js_1.default(0);
+        }
+        const userSharesAccount = (0, spl_token_1.unpackAccount)(userSharesAta, userSharesAccountInfo);
+        return new decimal_js_1.default(new decimal_js_1.default(userSharesAccount.amount.toString()).toNumber()).div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toNumber()));
     }
     /**
      * This method returns the user shares balance for all existing vaults
@@ -355,31 +336,29 @@ class KaminoVaultClient {
      * @param vaultsOverride - the kamino vaults if already fetched, in order to reduce rpc calls
      * @returns - hash map with keyh as vault address and value as user share balance in decimal (not lamports)
      */
-    getUserSharesBalanceAllVaults(user, vaultsOverride) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaults = vaultsOverride ? vaultsOverride : yield this.getAllVaults();
-            // stores vault address for each userSharesAta
-            const vaultUserShareBalance = new lib_1.PubkeyHashMap();
-            const userSharesAtaArray = [];
-            vaults.forEach((vault) => {
-                const state = vault.state;
-                if (!state) {
-                    throw new Error(`Vault ${vault.address.toBase58()} not fetched`);
-                }
-                const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(state.sharesMint, user);
-                userSharesAtaArray.push(userSharesAta);
-            });
-            const userSharesAtaAccounts = yield this._connection.getMultipleAccountsInfo(userSharesAtaArray);
-            userSharesAtaAccounts.forEach((userShareAtaAccount, index) => {
-                if (!userShareAtaAccount) {
-                    vaultUserShareBalance.set(vaults[index].address, new decimal_js_1.default(0));
-                }
-                else {
-                    vaultUserShareBalance.set(vaults[index].address, new decimal_js_1.default(userShareAtaAccount.lamports).div(new decimal_js_1.default(10).pow(vaults[index].state.sharesMintDecimals.toNumber())));
-                }
-            });
-            return vaultUserShareBalance;
+    async getUserSharesBalanceAllVaults(user, vaultsOverride) {
+        const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
+        // stores vault address for each userSharesAta
+        const vaultUserShareBalance = new lib_1.PubkeyHashMap();
+        const userSharesAtaArray = [];
+        vaults.forEach((vault) => {
+            const state = vault.state;
+            if (!state) {
+                throw new Error(`Vault ${vault.address.toBase58()} not fetched`);
+            }
+            const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(state.sharesMint, user);
+            userSharesAtaArray.push(userSharesAta);
         });
+        const userSharesAtaAccounts = await this._connection.getMultipleAccountsInfo(userSharesAtaArray);
+        userSharesAtaAccounts.forEach((userShareAtaAccount, index) => {
+            if (!userShareAtaAccount) {
+                vaultUserShareBalance.set(vaults[index].address, new decimal_js_1.default(0));
+            }
+            else {
+                vaultUserShareBalance.set(vaults[index].address, new decimal_js_1.default(userShareAtaAccount.lamports).div(new decimal_js_1.default(10).pow(vaults[index].state.sharesMintDecimals.toNumber())));
+            }
+        });
+        return vaultUserShareBalance;
     }
     /**
      * This method calculates the token per shar value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
@@ -387,10 +366,42 @@ class KaminoVaultClient {
      * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
      * @returns - token per share value
      */
-    getTokensPerShareSingleVault(vault, slot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const reserves = yield this.loadVaultReserves(vaultState);
+    async getTokensPerShareSingleVault(vault, slot) {
+        const vaultState = await vault.getState(this._connection);
+        const reserves = await this.loadVaultReserves(vaultState);
+        const totalVaultLiquidityAmount = new decimal_js_1.default(vaultState.tokenAvailable.toString());
+        vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
+            if (!allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
+                const reserve = reserves.get(allocationStrategy.reserve);
+                if (reserve === undefined) {
+                    throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+                }
+                const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, new fraction_1.Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+                    .toDecimal()
+                    .div(reserve.state.config.protocolTakeRatePct / 100)
+                    .floor()
+                    .toNumber());
+                const reserveAllocationLiquidityAmount = new decimal_js_1.default(allocationStrategy.cTokenAllocation.toString()).div(reserveCollExchangeRate);
+                totalVaultLiquidityAmount.add(reserveAllocationLiquidityAmount);
+            }
+        });
+        return new decimal_js_1.default(vaultState.sharesIssued.toString()).div(totalVaultLiquidityAmount);
+    }
+    /**
+     * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
+     * @param vault - vault to calculate tokensPerShare for
+     * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+     * @returns - token per share value
+     */
+    async getTokensPerShareAllVaults(slot, vaultsOverride) {
+        const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
+        const vaultTokensPerShare = new lib_1.PubkeyHashMap();
+        vaults.forEach(async (vault) => {
+            const vaultState = vault.state;
+            if (!vaultState) {
+                throw new Error(`Vault ${vault.address.toBase58()} not fetched`);
+            }
+            const reserves = await this.loadVaultReserves(vaultState);
             const totalVaultLiquidityAmount = new decimal_js_1.default(vaultState.tokenAvailable.toString());
             vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
                 if (!allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
@@ -407,45 +418,9 @@ class KaminoVaultClient {
                     totalVaultLiquidityAmount.add(reserveAllocationLiquidityAmount);
                 }
             });
-            return new decimal_js_1.default(vaultState.sharesIssued.toString()).div(totalVaultLiquidityAmount);
-        });
-    }
-    /**
-     * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
-     * @param vault - vault to calculate tokensPerShare for
-     * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
-     * @returns - token per share value
-     */
-    getTokensPerShareAllVaults(slot, vaultsOverride) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaults = vaultsOverride ? vaultsOverride : yield this.getAllVaults();
-            const vaultTokensPerShare = new lib_1.PubkeyHashMap();
-            vaults.forEach((vault) => __awaiter(this, void 0, void 0, function* () {
-                const vaultState = vault.state;
-                if (!vaultState) {
-                    throw new Error(`Vault ${vault.address.toBase58()} not fetched`);
-                }
-                const reserves = yield this.loadVaultReserves(vaultState);
-                const totalVaultLiquidityAmount = new decimal_js_1.default(vaultState.tokenAvailable.toString());
-                vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
-                    if (!allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
-                        const reserve = reserves.get(allocationStrategy.reserve);
-                        if (reserve === undefined) {
-                            throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
-                        }
-                        const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, new fraction_1.Fraction(reserve.state.liquidity.absoluteReferralRateSf)
-                            .toDecimal()
-                            .div(reserve.state.config.protocolTakeRatePct / 100)
-                            .floor()
-                            .toNumber());
-                        const reserveAllocationLiquidityAmount = new decimal_js_1.default(allocationStrategy.cTokenAllocation.toString()).div(reserveCollExchangeRate);
-                        totalVaultLiquidityAmount.add(reserveAllocationLiquidityAmount);
-                    }
-                });
-                vaultTokensPerShare.set(vault.address, new decimal_js_1.default(vaultState.sharesIssued.toString()).div(totalVaultLiquidityAmount));
-            }));
-            return vaultTokensPerShare;
+            vaultTokensPerShare.set(vault.address, new decimal_js_1.default(vaultState.sharesIssued.toString()).div(totalVaultLiquidityAmount));
         });
+        return vaultTokensPerShare;
     }
     /**
      * This will return an unsorted hash map of all reserves that the given vault has allocations for, toghether with the amount that can be withdrawn from each of the reserves
@@ -453,123 +428,115 @@ class KaminoVaultClient {
      * @param slot - current slot
      * @returns an HashMap of reserves (key) with the amount available to withdraw for each (value)
      */
-    getReserveAllocationAvailableLiquidityToWithdraw(vault, slot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultState = yield vault.getState(this._connection);
-            const reserves = yield this.loadVaultReserves(vaultState);
-            const reserveAllocationAvailableLiquidityToWithdraw = new lib_1.PubkeyHashMap();
-            vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
-                const reserve = reserves.get(allocationStrategy.reserve);
-                if (reserve === undefined) {
-                    throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
-                }
-                const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, new fraction_1.Fraction(reserve.state.liquidity.absoluteReferralRateSf)
-                    .toDecimal()
-                    .div(reserve.state.config.protocolTakeRatePct / 100)
-                    .floor()
-                    .toNumber());
-                const reserveAllocationLiquidityAmount = new decimal_js_1.default(allocationStrategy.cTokenAllocation.toString()).div(reserveCollExchangeRate);
-                const reserveAvailableLiquidityAmount = reserve.getLiquidityAvailableAmount();
-                reserveAllocationAvailableLiquidityToWithdraw.set(allocationStrategy.reserve, decimal_js_1.default.min(reserveAllocationLiquidityAmount, reserveAvailableLiquidityAmount));
-            });
-            return reserveAllocationAvailableLiquidityToWithdraw;
+    async getReserveAllocationAvailableLiquidityToWithdraw(vault, slot) {
+        const vaultState = await vault.getState(this._connection);
+        const reserves = await this.loadVaultReserves(vaultState);
+        const reserveAllocationAvailableLiquidityToWithdraw = new lib_1.PubkeyHashMap();
+        vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
+            const reserve = reserves.get(allocationStrategy.reserve);
+            if (reserve === undefined) {
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+            }
+            const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, new fraction_1.Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+                .toDecimal()
+                .div(reserve.state.config.protocolTakeRatePct / 100)
+                .floor()
+                .toNumber());
+            const reserveAllocationLiquidityAmount = new decimal_js_1.default(allocationStrategy.cTokenAllocation.toString()).div(reserveCollExchangeRate);
+            const reserveAvailableLiquidityAmount = reserve.getLiquidityAvailableAmount();
+            reserveAllocationAvailableLiquidityToWithdraw.set(allocationStrategy.reserve, decimal_js_1.default.min(reserveAllocationLiquidityAmount, reserveAvailableLiquidityAmount));
         });
+        return reserveAllocationAvailableLiquidityToWithdraw;
     }
     getVaultReserves(vault) {
         return vault.vaultAllocationStrategy
             .filter((vaultAllocation) => !vaultAllocation.reserve.equals(web3_js_1.PublicKey.default))
             .map((vaultAllocation) => vaultAllocation.reserve);
     }
-    loadVaultReserves(vaultState) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultReservesAddresses = this.getVaultReserves(vaultState);
-            const reserveAccounts = yield this._connection.getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
-            const deserializedReserves = reserveAccounts.map((reserve, i) => {
-                if (reserve === null) {
-                    // maybe reuse old here
-                    throw new Error(`Reserve account ${vaultReservesAddresses[i].toBase58()} was not found`);
-                }
-                const reserveAccount = lib_1.Reserve.decode(reserve.data);
-                if (!reserveAccount) {
-                    throw Error(`Could not parse reserve ${vaultReservesAddresses[i].toBase58()}`);
-                }
-                return reserveAccount;
-            });
-            const reservesAndOracles = yield (0, lib_1.getTokenOracleData)(this._connection, deserializedReserves);
-            const kaminoReserves = new lib_1.PubkeyHashMap();
-            reservesAndOracles.forEach(([reserve, oracle], index) => {
-                if (!oracle) {
-                    throw Error(`Could not find oracle for ${(0, utils_1.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
-                }
-                const kaminoReserve = lib_1.KaminoReserve.initialize(reserveAccounts[index], vaultReservesAddresses[index], reserve, oracle, this._connection, this.recentSlotDurationMs);
-                kaminoReserves.set(kaminoReserve.address, kaminoReserve);
-            });
-            return kaminoReserves;
+    async loadVaultReserves(vaultState) {
+        const vaultReservesAddresses = this.getVaultReserves(vaultState);
+        const reserveAccounts = await this._connection.getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
+        const deserializedReserves = reserveAccounts.map((reserve, i) => {
+            if (reserve === null) {
+                // maybe reuse old here
+                throw new Error(`Reserve account ${vaultReservesAddresses[i].toBase58()} was not found`);
+            }
+            const reserveAccount = lib_1.Reserve.decode(reserve.data);
+            if (!reserveAccount) {
+                throw Error(`Could not parse reserve ${vaultReservesAddresses[i].toBase58()}`);
+            }
+            return reserveAccount;
+        });
+        const reservesAndOracles = await (0, lib_1.getTokenOracleData)(this._connection, deserializedReserves);
+        const kaminoReserves = new lib_1.PubkeyHashMap();
+        reservesAndOracles.forEach(([reserve, oracle], index) => {
+            if (!oracle) {
+                throw Error(`Could not find oracle for ${(0, utils_1.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
+            }
+            const kaminoReserve = lib_1.KaminoReserve.initialize(reserveAccounts[index], vaultReservesAddresses[index], reserve, oracle, this._connection, this.recentSlotDurationMs);
+            kaminoReserves.set(kaminoReserve.address, kaminoReserve);
         });
+        return kaminoReserves;
     }
     /**
      * Get all vaults
      * @returns an array of all vaults
      */
-    getAllVaults() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { getProgramAccounts } = yield Promise.resolve().then(() => __importStar(require('../utils/rpc')));
-            const filters = [
-                {
-                    dataSize: accounts_1.VaultState.layout.span + 8,
-                },
-            ];
-            const [, kaminoVaults] = yield Promise.all([
-                this._connection.getSlot(),
-                getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
-                    commitment: (_a = this._connection.commitment) !== null && _a !== void 0 ? _a : 'processed',
-                    filters,
-                }),
-            ]);
-            return kaminoVaults.map((kaminoVault) => {
-                if (kaminoVault.account === null) {
-                    throw new Error('Invalid account');
-                }
-                const kaminoVaultAccount = accounts_1.VaultState.decode(kaminoVault.account.data);
-                if (!kaminoVaultAccount) {
-                    throw Error('Could not parse obligation.');
-                }
-                return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
-            });
+    async getAllVaults() {
+        const { getProgramAccounts } = await Promise.resolve().then(() => __importStar(require('../utils/rpc')));
+        const filters = [
+            {
+                dataSize: accounts_1.VaultState.layout.span + 8,
+            },
+        ];
+        const [, kaminoVaults] = await Promise.all([
+            this._connection.getSlot(),
+            getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+                commitment: this._connection.commitment ?? 'processed',
+                filters,
+            }),
+        ]);
+        return kaminoVaults.map((kaminoVault) => {
+            if (kaminoVault.account === null) {
+                throw new Error('Invalid account');
+            }
+            const kaminoVaultAccount = accounts_1.VaultState.decode(kaminoVault.account.data);
+            if (!kaminoVaultAccount) {
+                throw Error('Could not parse obligation.');
+            }
+            return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
         });
     }
 } // KaminoVaultClient
 exports.KaminoVaultClient = KaminoVaultClient;
 class KaminoVault {
+    address;
+    state;
+    programId;
     constructor(vaultAddress, state, programId = exports.kaminoVaultId) {
         this.address = vaultAddress;
         this.state = state;
         this.programId = programId;
     }
-    getState(connection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.state) {
-                const res = yield accounts_1.VaultState.fetch(connection, this.address, this.programId);
-                if (!res) {
-                    throw new Error('Invalid vault');
-                }
-                this.state = res;
-                return res;
-            }
-            else {
-                return this.state;
-            }
-        });
-    }
-    reloadState(connection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.state = yield accounts_1.VaultState.fetch(connection, this.address, this.programId);
-            if (!this.state) {
-                throw new Error('Could not fetch vault');
+    async getState(connection) {
+        if (!this.state) {
+            const res = await accounts_1.VaultState.fetch(connection, this.address, this.programId);
+            if (!res) {
+                throw new Error('Invalid vault');
             }
+            this.state = res;
+            return res;
+        }
+        else {
             return this.state;
-        });
+        }
+    }
+    async reloadState(connection) {
+        this.state = await accounts_1.VaultState.fetch(connection, this.address, this.programId);
+        if (!this.state) {
+            throw new Error('Could not fetch vault');
+        }
+        return this.state;
     }
 }
 exports.KaminoVault = KaminoVault;
@@ -577,6 +544,16 @@ exports.KaminoVault = KaminoVault;
  * Used to initialize a Kamino Vault
  */
 class KaminoVaultConfig {
+    /** The admin of the vault */
+    admin;
+    /** The token mint for the vault */
+    tokenMint;
+    /** The token mint program id */
+    tokenMintProgramId;
+    /** The performance fee rate of the vault, expressed as a decimal */
+    performanceFeeRate;
+    /** The management fee rate of the vault, expressed as a decimal */
+    managementFeeRate;
     constructor(args) {
         this.admin = args.admin;
         this.tokenMint = args.tokenMint;
@@ -593,6 +570,9 @@ class KaminoVaultConfig {
 }
 exports.KaminoVaultConfig = KaminoVaultConfig;
 class ReserveAllocationConfig {
+    reserve;
+    targetAllocationWeight;
+    allocationCapDecimal;
     constructor(reserve, targetAllocationWeight, allocationCapDecimal) {
         this.reserve = reserve;
         this.targetAllocationWeight = targetAllocationWeight;