@kamino-finance/klend-sdk 5.15.3 → 5.15.4

package/dist/classes/vault.js

@@ -7,15 +7,18 @@ exports.ReserveAllocationConfig = exports.KaminoVaultConfig = exports.KaminoVaul
 exports.getCTokenVaultPda = getCTokenVaultPda;
 exports.getEventAuthorityPda = getEventAuthorityPda;
 exports.printHoldings = printHoldings;
-const bn_js_1 = __importDefault(require("bn.js"));
-const kit_1 = require("@solana/kit");
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
 const lib_1 = require("../lib");
-const instructions_1 = require("../@codegen/kvault/instructions");
-const types_1 = require("../@codegen/kvault/types");
-const accounts_1 = require("../@codegen/kvault/accounts");
+const instructions_1 = require("../idl_codegen_kamino_vault/instructions");
+const types_1 = require("../idl_codegen_kamino_vault/types");
+const accounts_1 = require("../idl_codegen_kamino_vault/accounts");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const utils_1 = require("./utils");
-const programId_1 = require("../@codegen/klend/programId");
+const instructions_2 = require("../idl_codegen_kamino_vault/instructions");
+const instructions_3 = require("../idl_codegen_kamino_vault/instructions");
+const programId_1 = require("../idl_codegen/programId");
 const fraction_1 = require("./fraction");
 const utils_2 = require("../utils");
 const bs58_1 = __importDefault(require("bs58"));
@@ -25,42 +28,34 @@ const CreationParameters_1 = require("@kamino-finance/kliquidity-sdk/dist/utils/
 const dist_1 = require("@kamino-finance/farms-sdk/dist");
 const lookupTable_1 = require("../utils/lookupTable");
 const farm_utils_1 = require("./farm_utils");
-const system_1 = require("@solana-program/system");
 const metadata_1 = require("../utils/metadata");
 const vault_1 = require("../utils/vault");
-const token_2022_1 = require("@solana-program/token-2022");
-const token_1 = require("@solana-program/token");
-const sysvars_1 = require("@solana/sysvars");
-const signer_1 = require("../utils/signer");
-const address_lookup_table_1 = require("@solana-program/address-lookup-table");
-const farms_sdk_1 = require("@kamino-finance/farms-sdk");
-exports.kaminoVaultId = (0, kit_1.address)('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
-exports.kaminoVaultStagingId = (0, kit_1.address)('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
+exports.kaminoVaultId = new web3_js_1.PublicKey('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
+exports.kaminoVaultStagingId = new web3_js_1.PublicKey('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
 const BASE_VAULT_AUTHORITY_SEED = 'authority';
 const SHARES_SEED = 'shares';
 const EVENT_AUTHORITY_SEED = '__event_authority';
 exports.METADATA_SEED = 'metadata';
-exports.METADATA_PROGRAM_ID = (0, kit_1.address)('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
+exports.METADATA_PROGRAM_ID = new web3_js_1.PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
 exports.INITIAL_DEPOSIT_LAMPORTS = 1000;
-const addressEncoder = (0, kit_1.getAddressEncoder)();
 /**
  * KaminoVaultClient is a class that provides a high-level interface to interact with the Kamino Vault program.
  */
 class KaminoVaultClient {
-    _rpc;
+    _connection;
     _kaminoVaultProgramId;
     _kaminoLendProgramId;
     recentSlotDurationMs;
-    constructor(rpc, recentSlotDurationMs, kaminoVaultprogramId, kaminoLendProgramId) {
-        this._rpc = rpc;
+    constructor(connection, recentSlotDurationMs, kaminoVaultprogramId, kaminoLendProgramId) {
+        this._connection = connection;
         this.recentSlotDurationMs = recentSlotDurationMs;
         this._kaminoVaultProgramId = kaminoVaultprogramId ? kaminoVaultprogramId : exports.kaminoVaultId;
         this._kaminoLendProgramId = kaminoLendProgramId ? kaminoLendProgramId : programId_1.PROGRAM_ID;
     }
     getConnection() {
-        return this._rpc;
+        return this._connection;
     }
     getProgramID() {
         return this._kaminoVaultProgramId;
@@ -82,7 +77,7 @@ class KaminoVaultClient {
         }
         const kaminoVault = new KaminoVault(vaultPubkey, vault, this._kaminoVaultProgramId);
         const vaultName = this.decodeVaultName(vault.name);
-        const slot = await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
+        const slot = await this.getConnection().getSlot('confirmed');
         const tokensPerShare = await this.getTokensPerShareSingleVault(kaminoVault, slot);
         const holdings = await this.getVaultHoldings(vault, slot);
         const sharesIssued = new decimal_js_1.default(vault.sharesIssued.toString()).div(new decimal_js_1.default(vault.sharesMintDecimals.toString()));
@@ -97,91 +92,76 @@ class KaminoVaultClient {
      * @returns vault: the keypair of the vault, used to sign the initialization transaction; initVaultIxs: a struct with ixs to initialize the vault and its lookup table + populateLUTIxs, a list to populate the lookup table which has to be executed in a separate transaction
      */
     async createVaultIxs(vaultConfig) {
-        const vaultState = await (0, kit_1.generateKeyPairSigner)();
-        const size = BigInt(accounts_1.VaultState.layout.span + 8);
-        const createVaultIx = (0, system_1.getCreateAccountInstruction)({
-            payer: vaultConfig.admin,
+        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.getConnection().getMinimumBalanceForRentExemption(size),
             space: size,
-            lamports: await this.getConnection().getMinimumBalanceForRentExemption(size).send(),
-            programAddress: this._kaminoVaultProgramId,
-            newAccount: vaultState,
+            programId: this._kaminoVaultProgramId,
         });
-        const [slot, [tokenVault], [baseVaultAuthority], [sharesMint]] = await Promise.all([
-            this.getConnection().getSlot({ commitment: 'finalized' }).send(),
-            (0, kit_1.getProgramDerivedAddress)({
-                seeds: [Buffer.from(TOKEN_VAULT_SEED), addressEncoder.encode(vaultState.address)],
-                programAddress: this._kaminoVaultProgramId,
-            }),
-            (0, kit_1.getProgramDerivedAddress)({
-                seeds: [Buffer.from(BASE_VAULT_AUTHORITY_SEED), addressEncoder.encode(vaultState.address)],
-                programAddress: this._kaminoVaultProgramId,
-            }),
-            (0, kit_1.getProgramDerivedAddress)({
-                seeds: [Buffer.from(SHARES_SEED), addressEncoder.encode(vaultState.address)],
-                programAddress: 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_SEED), vaultState.publicKey.toBytes()], this._kaminoVaultProgramId)[0];
         let adminTokenAccount;
         const prerequisiteIxs = [];
         const cleanupIxs = [];
-        if (vaultConfig.tokenMint === lib_1.WRAPPED_SOL_MINT) {
+        if (vaultConfig.tokenMint.equals(spl_token_1.NATIVE_MINT)) {
             const { wsolAta, createAtaIxs, closeAtaIxs } = await (0, utils_2.createWsolAtaIfMissing)(this.getConnection(), new decimal_js_1.default(utils_2.VAULT_INITIAL_DEPOSIT), vaultConfig.admin);
             adminTokenAccount = wsolAta;
             prerequisiteIxs.push(...createAtaIxs);
             cleanupIxs.push(...closeAtaIxs);
         }
         else {
-            adminTokenAccount = (await (0, token_2022_1.findAssociatedTokenPda)({
-                mint: vaultConfig.tokenMint,
-                tokenProgram: vaultConfig.tokenMintProgramId,
-                owner: vaultConfig.admin.address,
-            }))[0];
+            adminTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(vaultConfig.tokenMint, vaultConfig.admin, false, vaultConfig.tokenMintProgramId);
         }
         const initVaultAccounts = {
             adminAuthority: vaultConfig.admin,
-            vaultState: vaultState.address,
+            vaultState: vaultState.publicKey,
             baseTokenMint: vaultConfig.tokenMint,
             tokenVault,
             baseVaultAuthority,
             sharesMint,
-            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
-            rent: sysvars_1.SYSVAR_RENT_ADDRESS,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
             tokenProgram: vaultConfig.tokenMintProgramId,
-            sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             adminTokenAccount,
         };
         const initVaultIx = (0, instructions_1.initVault)(initVaultAccounts, this._kaminoVaultProgramId);
         // create and set up the vault lookup table
-        const [createLUTIx, lut] = await (0, lookupTable_1.initLookupTableIx)(vaultConfig.admin, slot);
+        const slot = await this.getConnection().getSlot();
+        const [createLUTIx, lut] = (0, lookupTable_1.initLookupTableIx)(vaultConfig.admin, slot);
         const accountsToBeInserted = [
-            vaultConfig.admin.address,
-            vaultState.address,
+            vaultConfig.admin,
+            vaultState.publicKey,
             vaultConfig.tokenMint,
             vaultConfig.tokenMintProgramId,
             baseVaultAuthority,
             sharesMint,
-            system_1.SYSTEM_PROGRAM_ADDRESS,
-            sysvars_1.SYSVAR_RENT_ADDRESS,
-            token_1.TOKEN_PROGRAM_ADDRESS,
+            web3_js_1.SystemProgram.programId,
+            web3_js_1.SYSVAR_RENT_PUBKEY,
+            spl_token_1.TOKEN_PROGRAM_ID,
             this._kaminoLendProgramId,
-            sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
+            web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
         ];
         const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultConfig.admin, lut, accountsToBeInserted, []);
-        const setLUTIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.LookupTable(), lut.toString());
+        const setLUTIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.LookupTable(), lut.toString());
         const ixs = [createVaultIx, initVaultIx, setLUTIx];
         if (vaultConfig.getPerformanceFeeBps() > 0) {
-            const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.PerformanceFeeBps(), vaultConfig.getPerformanceFeeBps().toString());
+            const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.PerformanceFeeBps(), vaultConfig.getPerformanceFeeBps().toString());
             ixs.push(setPerformanceFeeIx);
         }
         if (vaultConfig.getManagementFeeBps() > 0) {
-            const setManagementFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.ManagementFeeBps(), vaultConfig.getManagementFeeBps().toString());
+            const setManagementFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.ManagementFeeBps(), vaultConfig.getManagementFeeBps().toString());
             ixs.push(setManagementFeeIx);
         }
         if (vaultConfig.name && vaultConfig.name.length > 0) {
-            const setNameIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.Name(), vaultConfig.name);
+            const setNameIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.Name(), vaultConfig.name);
             ixs.push(setNameIx);
         }
-        const metadataIx = await this.getSetSharesMetadataIx(this.getConnection(), vaultConfig.admin, vaultState.address, sharesMint, baseVaultAuthority, vaultConfig.vaultTokenSymbol, vaultConfig.vaultTokenName);
+        const metadataIx = await this.getSetSharesMetadataIx(this.getConnection(), vaultConfig.admin, vaultState.publicKey, sharesMint, baseVaultAuthority, vaultConfig.vaultTokenSymbol, vaultConfig.vaultTokenName);
         return {
             vault: vaultState,
             initVaultIxs: {
@@ -196,62 +176,58 @@ class KaminoVaultClient {
     }
     /**
      * This method creates an instruction to set the shares metadata for a vault
-     * @param rpc
-     * @param vaultAdmin
      * @param vault - the vault to set the shares metadata for
-     * @param sharesMint
-     * @param baseVaultAuthority
      * @param tokenName - the name of the token in the vault (symbol; e.g. "USDC" which becomes "kVUSDC")
      * @param extraName - the extra string appended to the prefix("Kamino Vault USDC <extraName>")
      * @returns - an instruction to set the shares metadata for the vault
      */
-    async getSetSharesMetadataIx(rpc, vaultAdmin, vault, sharesMint, baseVaultAuthority, tokenName, extraName) {
-        const [sharesMintMetadata] = await (0, utils_2.getKVaultSharesMetadataPda)(sharesMint);
+    async getSetSharesMetadataIx(connection, vaultAdmin, vault, sharesMint, baseVaultAuthority, tokenName, extraName) {
+        const [sharesMintMetadata] = (0, utils_2.getKVaultSharesMetadataPda)(sharesMint);
         const { name, symbol, uri } = (0, metadata_1.resolveMetadata)(sharesMint, extraName, tokenName);
-        const ix = !(await (0, kit_1.fetchEncodedAccount)(rpc, sharesMintMetadata, { commitment: 'processed' })).exists
-            ? await (0, metadata_1.getInitializeKVaultSharesMetadataIx)(vaultAdmin, vault, sharesMint, baseVaultAuthority, name, symbol, uri)
-            : await (0, metadata_1.getUpdateSharesMetadataIx)(vaultAdmin, vault, sharesMint, baseVaultAuthority, name, symbol, uri);
+        const ix = (await connection.getAccountInfo(sharesMintMetadata)) === null
+            ? await (0, metadata_1.getInitializeKVaultSharesMetadataIx)(connection, vaultAdmin, vault, sharesMint, baseVaultAuthority, name, symbol, uri)
+            : await (0, metadata_1.getUpdateSharesMetadataIx)(connection, vaultAdmin, vault, sharesMint, baseVaultAuthority, name, symbol, uri);
         return ix;
     }
     /**
-     * This method updates the vault reserve allocation config for an exiting vault reserve, or adds a new reserve to the vault if it does not exist.
+     * 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.
      * @param vault - vault to be updated
      * @param reserveAllocationConfig - new reserve allocation config
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
+     * @param [signer] - optional parameter to pass a different signer for the instruction. If not provided, the admin of the vault will be used
      * @returns - a struct with an instruction to update the reserve allocation and an optional list of instructions to update the lookup table for the allocation changes
      */
-    async updateReserveAllocationIxs(vault, reserveAllocationConfig, vaultAdminAuthority) {
+    async updateReserveAllocationIxs(vault, reserveAllocationConfig, signer) {
         const vaultState = await vault.getState(this.getConnection());
         const reserveState = reserveAllocationConfig.getReserveState();
-        const cTokenVault = await getCTokenVaultPda(vault.address, reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
-        const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
+        const cTokenVault = getCTokenVaultPda(vault.address, reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
+        const allocationSigner = signer ? signer : vaultState.vaultAdminAuthority;
         const updateReserveAllocationAccounts = {
-            signer: vaultAdmin,
+            signer: allocationSigner,
             vaultState: vault.address,
             baseVaultAuthority: vaultState.baseVaultAuthority,
             reserveCollateralMint: reserveState.collateral.mintPubkey,
             reserve: reserveAllocationConfig.getReserveAddress(),
             ctokenVault: cTokenVault,
-            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
-            rent: sysvars_1.SYSVAR_RENT_ADDRESS,
-            reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            reserveCollateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         const updateReserveAllocationArgs = {
-            weight: new bn_js_1.default(reserveAllocationConfig.targetAllocationWeight),
-            cap: new bn_js_1.default(reserveAllocationConfig.getAllocationCapLamports().floor().toString()),
+            weight: new anchor_1.BN(reserveAllocationConfig.targetAllocationWeight),
+            cap: new anchor_1.BN(reserveAllocationConfig.getAllocationCapLamports().floor().toString()),
         };
         const updateReserveAllocationIx = (0, instructions_1.updateReserveAllocation)(updateReserveAllocationArgs, updateReserveAllocationAccounts, this._kaminoVaultProgramId);
-        const accountsToAddToLut = [
+        const accountsToAddToLUT = [
             reserveAllocationConfig.getReserveAddress(),
             cTokenVault,
             ...this.getReserveAccountsToInsertInLut(reserveState),
         ];
-        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(reserveState.lendingMarket, this._kaminoLendProgramId);
-        accountsToAddToLut.push(lendingMarketAuth);
-        const insertIntoLutIxs = await this.insertIntoLookupTableIxs(vaultAdmin, vaultState.vaultLookupTable, accountsToAddToLut);
+        const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(reserveState.lendingMarket, this._kaminoLendProgramId)[0];
+        accountsToAddToLUT.push(lendingMarketAuth);
+        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultState.vaultAdminAuthority, vaultState.vaultLookupTable, accountsToAddToLUT);
         const updateReserveAllocationIxs = {
             updateReserveAllocationIx,
-            updateLUTIxs: insertIntoLutIxs,
+            updateLUTIxs: insertIntoLUTIxs,
         };
         return updateReserveAllocationIxs;
     }
@@ -259,12 +235,12 @@ class KaminoVaultClient {
      * This method withdraws all the funds from a reserve and blocks it from being invested by setting its weight and ctoken allocation to 0
      * @param vault - the vault to withdraw the funds from
      * @param reserve - the reserve to withdraw the funds from
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
+     * @param payer - the payer of the transaction. If not provided, the admin of the vault will be used
      * @returns - a struct with an instruction to update the reserve allocation and an optional list of instructions to update the lookup table for the allocation changes
      */
-    async withdrawEverythingAndBlockInvestReserve(vault, reserve, vaultAdminAuthority) {
+    async withdrawEverythingAndBlockInvestReserve(vault, reserve, payer) {
         const vaultState = await vault.getState(this.getConnection());
-        const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve === reserve);
+        const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve.equals(reserve));
         const withdrawAndBlockReserveIxs = {
             updateReserveAllocationIxs: [],
             investIxs: [],
@@ -273,7 +249,7 @@ class KaminoVaultClient {
             return withdrawAndBlockReserveIxs;
         }
         const reserveState = await lib_1.Reserve.fetch(this.getConnection(), reserve);
-        if (reserveState === null) {
+        if (!reserveState) {
             return withdrawAndBlockReserveIxs;
         }
         const reserveWithAddress = {
@@ -281,10 +257,10 @@ class KaminoVaultClient {
             state: reserveState,
         };
         const reserveAllocationConfig = new ReserveAllocationConfig(reserveWithAddress, 0, new decimal_js_1.default(0));
-        const admin = vaultAdminAuthority ? vaultAdminAuthority : (0, signer_1.noopSigner)(vaultState.vaultAdminAuthority);
         // update allocation to have 0 weight and 0 cap
-        const updateAllocIxs = await this.updateReserveAllocationIxs(vault, reserveAllocationConfig, admin);
-        const investIx = await this.investSingleReserveIxs(admin, vault, reserveWithAddress);
+        const updateAllocIxs = await this.updateReserveAllocationIxs(vault, reserveAllocationConfig);
+        const investPayer = payer ? payer : vaultState.vaultAdminAuthority;
+        const investIx = await this.investSingleReserveIxs(investPayer, vault, reserveWithAddress);
         withdrawAndBlockReserveIxs.updateReserveAllocationIxs = [updateAllocIxs.updateReserveAllocationIx];
         withdrawAndBlockReserveIxs.investIxs = investIx;
         return withdrawAndBlockReserveIxs;
@@ -313,10 +289,10 @@ class KaminoVaultClient {
             };
             const reserveAllocationConfig = new ReserveAllocationConfig(reserveWithAddress, 0, new decimal_js_1.default(0));
             // update allocation to have 0 weight and 0 cap
-            const updateAllocIxs = await this.updateReserveAllocationIxs(vault, reserveAllocationConfig, payer);
+            const updateAllocIxs = await this.updateReserveAllocationIxs(vault, reserveAllocationConfig);
             withdrawAndBlockReserveIxs.updateReserveAllocationIxs.push(updateAllocIxs.updateReserveAllocationIx);
         }
-        const investPayer = payer ? payer : (0, signer_1.noopSigner)(vaultState.vaultAdminAuthority);
+        const investPayer = payer ? payer : vaultState.vaultAdminAuthority;
         const investIxs = await this.investAllReservesIxs(investPayer, vault);
         withdrawAndBlockReserveIxs.investIxs = investIxs;
         return withdrawAndBlockReserveIxs;
@@ -325,18 +301,16 @@ class KaminoVaultClient {
      * This method removes a reserve from the vault allocation strategy if already part of the allocation strategy
      * @param vault - vault to remove the reserve from
      * @param reserve - reserve to remove from the vault allocation strategy
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
      * @returns - an instruction to remove the reserve from the vault allocation strategy or undefined if the reserve is not part of the allocation strategy
      */
-    async removeReserveFromAllocationIx(vault, reserve, vaultAdminAuthority) {
+    async removeReserveFromAllocationIx(vault, reserve) {
         const vaultState = await vault.getState(this.getConnection());
-        const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
-        const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve === reserve);
+        const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve.equals(reserve));
         if (!reserveIsPartOfAllocation) {
             return undefined;
         }
         const accounts = {
-            vaultAdminAuthority: vaultAdmin,
+            vaultAdminAuthority: vaultState.vaultAdminAuthority,
             vaultState: vault.address,
             reserve,
         };
@@ -347,19 +321,18 @@ class KaminoVaultClient {
      * @param vault the vault to update
      * @param mode the field to update (based on VaultConfigFieldKind enum)
      * @param value the value to update the field with
-     * @param [vaultAdminAuthority] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
+     * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
      * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
      */
-    async updateVaultConfigIxs(vault, mode, value, vaultAdminAuthority) {
+    async updateVaultConfigIxs(vault, mode, value, signer) {
         const vaultState = await vault.getState(this.getConnection());
-        const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const updateVaultConfigAccs = {
-            vaultAdminAuthority: admin,
+            vaultAdminAuthority: vaultState.vaultAdminAuthority,
             vaultState: vault.address,
             klendProgram: this._kaminoLendProgramId,
         };
-        if (vaultAdminAuthority) {
-            updateVaultConfigAccs.vaultAdminAuthority = vaultAdminAuthority;
+        if (signer) {
+            updateVaultConfigAccs.vaultAdminAuthority = signer;
         }
         const updateVaultConfigArgs = {
             entry: mode,
@@ -371,8 +344,8 @@ class KaminoVaultClient {
                 updateVaultConfigArgs.data = Buffer.from(data);
             }
             else {
-                const data = (0, kit_1.address)(value);
-                updateVaultConfigArgs.data = Buffer.from(addressEncoder.encode(data));
+                const data = new web3_js_1.PublicKey(value);
+                updateVaultConfigArgs.data = data.toBuffer();
             }
         }
         else {
@@ -382,21 +355,36 @@ class KaminoVaultClient {
         }
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = await this.loadVaultReserves(vaultState);
-        let updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, this._kaminoVaultProgramId);
-        updateVaultConfigIx = this.appendRemainingAccountsForVaultReserves(updateVaultConfigIx, vaultReserves, vaultReservesState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
+        });
+        const updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, this._kaminoVaultProgramId);
+        updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesAccountMetas);
+        updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesLendingMarkets);
         const updateLUTIxs = [];
         if (mode.kind === new types_1.VaultConfigField.PendingVaultAdmin().kind) {
-            const newPubkey = (0, kit_1.address)(value);
-            const insertIntoLutIxs = await this.insertIntoLookupTableIxs(admin, vaultState.vaultLookupTable, [newPubkey]);
+            const newPubkey = new web3_js_1.PublicKey(value);
+            const insertIntoLutIxs = await this.insertIntoLookupTableIxs(vaultState.vaultAdminAuthority, vaultState.vaultLookupTable, [newPubkey]);
             updateLUTIxs.push(...insertIntoLutIxs);
         }
         else if (mode.kind === new types_1.VaultConfigField.Farm().kind) {
-            const keysToAddToLUT = [(0, kit_1.address)(value)];
+            const keysToAddToLUT = [new web3_js_1.PublicKey(value)];
             // if the farm already exist we want to read its state to add it to the LUT
             try {
                 const farmState = await dist_1.FarmState.fetch(this.getConnection(), keysToAddToLUT[0]);
                 keysToAddToLUT.push(farmState.farmVault, farmState.farmVaultsAuthority, farmState.token.mint, farmState.scopePrices, farmState.globalConfig);
-                const insertIntoLutIxs = await this.insertIntoLookupTableIxs(admin, vaultState.vaultLookupTable, keysToAddToLUT);
+                const insertIntoLutIxs = await this.insertIntoLookupTableIxs(vaultState.vaultAdminAuthority, vaultState.vaultLookupTable, keysToAddToLUT);
                 updateLUTIxs.push(...insertIntoLutIxs);
             }
             catch (error) {
@@ -413,19 +401,16 @@ class KaminoVaultClient {
      * @param vault - vault to set the farm for
      * @param farm - the farm where the vault shares can be staked
      * @param [errorOnOverride] - if true, the function will throw an error if the vault already has a farm. If false, it will override the farm
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
-     *
      */
-    async setVaultFarmIxs(vault, farm, errorOnOverride = true, vaultAdminAuthority) {
+    async setVaultFarmIxs(vault, farm, errorOnOverride = true) {
         const vaultHasFarm = await vault.hasFarm(this.getConnection());
         if (vaultHasFarm && errorOnOverride) {
             throw new Error('Vault already has a farm, if you want to override it set errorOnOverride to false');
         }
-        return this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.Farm(), farm, vaultAdminAuthority);
+        return this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.Farm(), farm.toBase58());
     }
     /**
      * This method updates the vault config for a vault that
-     * @param admin - address of vault to be updated
      * @param vault - address of vault to be updated
      * @param mode - the field to be updated
      * @param value - the new value for the field to be updated (number or pubkey)
@@ -447,8 +432,8 @@ class KaminoVaultClient {
                 updateVaultConfigArgs.data = Buffer.from(data);
             }
             else {
-                const data = (0, kit_1.address)(value);
-                updateVaultConfigArgs.data = Buffer.from(addressEncoder.encode(data));
+                const data = new web3_js_1.PublicKey(value);
+                updateVaultConfigArgs.data = data.toBuffer();
             }
         }
         else {
@@ -462,30 +447,28 @@ class KaminoVaultClient {
     /**
      * This function creates the instruction for the `pendingAdmin` of the vault to accept to become the owner of the vault (step 2/2 of the ownership transfer)
      * @param vault - vault to change the ownership for
-     * @param [pendingAdmin] - pending vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
      * @returns - an instruction to accept the ownership of the vault and a list of instructions to update the lookup table
      */
-    async acceptVaultOwnershipIxs(vault, pendingAdmin) {
+    async acceptVaultOwnershipIxs(vault) {
         const vaultState = await vault.getState(this.getConnection());
-        const signer = parseVaultPendingAdmin(vaultState, pendingAdmin);
         const acceptOwneshipAccounts = {
-            pendingAdmin: signer,
+            pendingAdmin: vaultState.pendingAdmin,
             vaultState: vault.address,
         };
         const acceptVaultOwnershipIx = (0, instructions_1.updateAdmin)(acceptOwneshipAccounts, this._kaminoVaultProgramId);
         // read the current LUT and create a new one for the new admin and backfill it
-        const accountsInExistentLUT = (await (0, lookupTable_1.getAccountsInLut)(this.getConnection(), vaultState.vaultLookupTable)).filter((account) => account !== vaultState.vaultAdminAuthority);
-        const lutIxs = [];
-        const [initNewLutIx, newLut] = await (0, lookupTable_1.initLookupTableIx)(signer, await this.getConnection().getSlot({ commitment: 'finalized' }).send());
-        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(signer, newLut, accountsInExistentLUT, []);
-        lutIxs.push(...insertIntoLUTIxs);
-        const updateVaultConfigIxs = await this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.LookupTable(), newLut.toString(), signer);
-        lutIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
-        lutIxs.push(...updateVaultConfigIxs.updateLUTIxs);
+        const accountsInExistentLUT = (await (0, lookupTable_1.getAccountsInLUT)(this.getConnection(), vaultState.vaultLookupTable)).filter((account) => !account.equals(vaultState.vaultAdminAuthority));
+        const LUTIxs = [];
+        const [initNewLUTIx, newLUT] = (0, lookupTable_1.initLookupTableIx)(vaultState.pendingAdmin, await this.getConnection().getSlot());
+        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultState.pendingAdmin, newLUT, accountsInExistentLUT, []);
+        LUTIxs.push(...insertIntoLUTIxs);
+        const updateVaultConfigIxs = await this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.LookupTable(), newLUT.toString(), vaultState.pendingAdmin);
+        LUTIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
+        LUTIxs.push(...updateVaultConfigIxs.updateLUTIxs);
         const acceptVaultOwnershipIxs = {
             acceptVaultOwnershipIx,
-            initNewLUTIx: initNewLutIx,
-            updateLUTIxs: lutIxs,
+            initNewLUTIx,
+            updateLUTIxs: LUTIxs,
         };
         return acceptVaultOwnershipIxs;
     }
@@ -493,40 +476,35 @@ class KaminoVaultClient {
      * This function creates the instruction for the admin to give up a part of the pending fees (which will be accounted as part of the vault)
      * @param vault - vault to give up pending fees for
      * @param maxAmountToGiveUp - the maximum amount of fees to give up, in tokens
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
      * @returns - an instruction to give up the specified pending fees
      */
-    async giveUpPendingFeesIx(vault, maxAmountToGiveUp, vaultAdminAuthority) {
+    async giveUpPendingFeesIx(vault, maxAmountToGiveUp) {
         const vaultState = await vault.getState(this.getConnection());
-        const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const giveUpPendingFeesAccounts = {
-            vaultAdminAuthority: vaultAdmin,
+            vaultAdminAuthority: vaultState.vaultAdminAuthority,
             vaultState: vault.address,
             klendProgram: this._kaminoLendProgramId,
         };
         const maxAmountToGiveUpLamports = (0, utils_1.numberToLamportsDecimal)(maxAmountToGiveUp, vaultState.tokenMintDecimals.toNumber());
         const giveUpPendingFeesArgs = {
-            maxAmountToGiveUp: new bn_js_1.default(maxAmountToGiveUpLamports.toString()),
+            maxAmountToGiveUp: new anchor_1.BN(maxAmountToGiveUpLamports.toString()),
         };
         return (0, instructions_1.giveUpPendingFees)(giveUpPendingFeesArgs, giveUpPendingFeesAccounts, this._kaminoVaultProgramId);
     }
     /**
      * This method withdraws all the pending fees from the vault to the owner's token ATA
-     * @param authority - vault admin
      * @param vault - vault for which the admin withdraws the pending fees
      * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
      * @param [vaultReservesMap] - a hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
-     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
      * @returns - list of instructions to withdraw all pending fees, including the ATA creation instructions if needed
      */
-    async withdrawPendingFeesIxs(vault, slot, vaultReservesMap, vaultAdminAuthority) {
+    async withdrawPendingFeesIxs(vault, slot, vaultReservesMap) {
         const vaultState = await vault.getState(this.getConnection());
-        const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-        const [{ ata: adminTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(vaultAdmin, [
+        const [{ ata: adminTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(vaultState.vaultAdminAuthority, [
             {
                 mint: vaultState.tokenMint,
-                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         ]);
         const tokensToWithdraw = new fraction_1.Fraction(vaultState.pendingFeesSf).toDecimal();
@@ -541,7 +519,7 @@ class KaminoVaultClient {
             // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
             const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(vault, slot, vaultReservesState);
             // sort
-            const reserveAllocationAvailableLiquidityToWithdrawSorted = new Map([...reserveAllocationAvailableLiquidityToWithdraw.entries()].sort((a, b) => b[1].sub(a[1]).toNumber()));
+            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);
@@ -552,15 +530,15 @@ class KaminoVaultClient {
         const reserveStates = await lib_1.Reserve.fetchMultiple(this.getConnection(), reservesToWithdraw, this._kaminoLendProgramId);
         const withdrawIxs = await Promise.all(reservesToWithdraw.map(async (reserve, index) => {
             if (reserveStates[index] === null) {
-                throw new Error(`Reserve ${reserve} not found`);
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
             }
             const reserveState = reserveStates[index];
             const marketAddress = reserveState.lendingMarket;
-            return this.withdrawPendingFeesIx(vaultAdmin, vault, vaultState, marketAddress, { address: reserve, state: reserveState }, adminTokenAta);
+            return this.withdrawPendingFeesIx(vault, vaultState, marketAddress, { address: reserve, state: reserveState }, adminTokenAta);
         }));
         return [createAtaIx, ...withdrawIxs];
     }
-    // async closeVaultIx(vault: KaminoVault): Promise<IInstruction> {
+    // async closeVaultIx(vault: KaminoVault): Promise<TransactionInstruction> {
     //   const vaultState: VaultState = await vault.getState(this.getConnection());
     //   const closeVaultAccounts: CloseVaultAccounts = {
     //     adminAuthority: vaultState.adminAuthority,
@@ -580,29 +558,29 @@ class KaminoVaultClient {
     async depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
         const vaultState = await vault.getState(this.getConnection());
         const tokenProgramID = vaultState.tokenProgram;
-        const userTokenAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user.address, tokenProgramID);
+        const userTokenAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user, true, tokenProgramID);
         const createAtasIxs = [];
         const closeAtasIxs = [];
-        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
-            const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = await (0, utils_2.createAtasIdempotent)(user, [
+        if (vaultState.tokenMint.equals(spl_token_1.NATIVE_MINT)) {
+            const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = (0, utils_2.createAtasIdempotent)(user, [
                 {
-                    mint: lib_1.WRAPPED_SOL_MINT,
-                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                    mint: spl_token_1.NATIVE_MINT,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 },
             ]);
             createAtasIxs.push(createWsolAtaIxn);
-            const transferWsolIxs = (0, lib_1.getTransferWsolIxs)(user, wsolAta, (0, kit_1.lamports)(BigInt((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil().toString())));
+            const transferWsolIxs = (0, lib_1.getTransferWsolIxs)(user, wsolAta, (0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil());
             createAtasIxs.push(...transferWsolIxs);
         }
-        const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxs }] = await (0, utils_2.createAtasIdempotent)(user, [
+        const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxs }] = (0, utils_2.createAtasIdempotent)(user, [
             {
                 mint: vaultState.sharesMint,
-                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         ]);
         createAtasIxs.push(createSharesAtaIxs);
-        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
-        const depositAccounts = {
+        const eventAuthority = getEventAuthorityPda(this._kaminoVaultProgramId);
+        const depoistAccounts = {
             user: user,
             vaultState: vault.address,
             tokenVault: vaultState.tokenVault,
@@ -613,17 +591,32 @@ class KaminoVaultClient {
             userSharesAta: userSharesAta,
             tokenProgram: tokenProgramID,
             klendProgram: this._kaminoLendProgramId,
-            sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             eventAuthority: eventAuthority,
             program: this._kaminoVaultProgramId,
         };
         const depositArgs = {
-            maxAmount: new bn_js_1.default((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()),
+            maxAmount: new anchor_1.BN((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()),
         };
-        let depositIx = (0, instructions_1.deposit)(depositArgs, depositAccounts, this._kaminoVaultProgramId);
+        const depositIx = (0, instructions_2.deposit)(depositArgs, depoistAccounts, this._kaminoVaultProgramId);
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-        depositIx = this.appendRemainingAccountsForVaultReserves(depositIx, vaultReserves, vaultReservesState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
+        });
+        depositIx.keys = depositIx.keys.concat(vaultReservesAccountMetas);
+        depositIx.keys = depositIx.keys.concat(vaultReservesLendingMarkets);
         const depositIxs = {
             depositIxs: [...createAtasIxs, depositIx, ...closeAtasIxs],
             stakeInFarmIfNeededIxs: [],
@@ -652,7 +645,7 @@ class KaminoVaultClient {
             sharesToStakeLamports = (0, utils_1.numberToLamportsDecimal)(sharesAmount, vaultState.sharesMintDecimals.toNumber());
         }
         // if tokens to be staked are 0 or vault has no farm there is no stake needed
-        if (sharesToStakeLamports.lte(0) || !(await vault.hasFarm(this.getConnection()))) {
+        if (sharesToStakeLamports.lte(0) || !vault.hasFarm(this.getConnection())) {
             return [];
         }
         // returns the ix to create the farm state account if needed and the ix to stake the shares
@@ -679,15 +672,15 @@ class KaminoVaultClient {
         };
         // compute the total shares the user has (in ATA + in farm) and check if they want to withdraw everything or just a part
         let userSharesAtaBalance = new decimal_js_1.default(0);
-        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
-        const userSharesAtaState = await (0, token_2022_1.fetchMaybeToken)(this.getConnection(), userSharesAta);
-        if (userSharesAtaState.exists) {
-            const userSharesAtaBalanceInLamports = (0, lib_1.getTokenBalanceFromAccountInfoLamports)(userSharesAtaState);
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const userSharesAtaState = await this.getConnection().getAccountInfo(userSharesAta);
+        if (userSharesAtaState) {
+            const userSharesAtaBalanceInLamports = (0, utils_1.getTokenBalanceFromAccountInfoLamports)(userSharesAtaState);
             userSharesAtaBalance = userSharesAtaBalanceInLamports.div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
         }
         let userSharesInFarm = new decimal_js_1.default(0);
         if (hasFarm) {
-            userSharesInFarm = await (0, farm_utils_1.getUserSharesInTokensStakedInFarm)(this.getConnection(), user.address, vaultState.vaultFarm, vaultState.sharesMintDecimals.toNumber());
+            userSharesInFarm = await (0, farm_utils_1.getUserSharesInTokensStakedInFarm)(this.getConnection(), user, vaultState.vaultFarm, vaultState.sharesMintDecimals.toNumber());
         }
         let sharesToWithdraw = shareAmountToWithdraw;
         const totalUserShares = userSharesAtaBalance.add(userSharesInFarm);
@@ -700,10 +693,10 @@ class KaminoVaultClient {
         const sharesInAtaAreEnoughForWithdraw = sharesToWithdraw.lte(userSharesAtaBalance);
         if (hasFarm && !sharesInAtaAreEnoughForWithdraw) {
             // if we need to unstake we need to make sure share ata is created
-            const [{ createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
+            const [{ createAtaIx }] = (0, utils_2.createAtasIdempotent)(user, [
                 {
                     mint: vaultState.sharesMint,
-                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 },
             ]);
             withdrawIxs.unstakeFromFarmIfNeededIxs.push(createAtaIx);
@@ -717,7 +710,7 @@ class KaminoVaultClient {
             withdrawIxs.unstakeFromFarmIfNeededIxs.push(unstakeAndWithdrawFromFarmIxs.withdrawIx);
         }
         // if the vault has allocations withdraw otherwise wtihdraw from available ix
-        const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) => allocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) => !allocation.reserve.equals(web3_js_1.PublicKey.default));
         if (vaultAllocation) {
             const withdrawFromVaultIxs = await this.withdrawWithReserveIxs(user, kaminoVault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
             withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
@@ -727,23 +720,15 @@ class KaminoVaultClient {
             withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
         }
         // if the vault is for SOL return the ix to unwrap the SOL
-        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
-            const userWsolAta = await (0, lib_1.getAssociatedTokenAddress)(lib_1.WRAPPED_SOL_MINT, user.address);
-            const unwrapIx = (0, token_2022_1.getCloseAccountInstruction)({
-                account: userWsolAta,
-                owner: user,
-                destination: user.address,
-            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+        if (vaultState.tokenMint.equals(spl_token_1.NATIVE_MINT)) {
+            const userWsolAta = (0, lib_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, user);
+            const unwrapIx = (0, spl_token_1.createCloseAccountInstruction)(userWsolAta, user, user, [], spl_token_1.TOKEN_PROGRAM_ID);
             withdrawIxs.postWithdrawIxs.push(unwrapIx);
         }
         // if we burn all of user's shares close its shares ATA
         const burnAllUserShares = sharesToWithdraw.gt(userSharesAtaBalance);
         if (burnAllUserShares) {
-            const closeAtaIx = (0, token_2022_1.getCloseAccountInstruction)({
-                account: userSharesAta,
-                owner: user,
-                destination: user.address,
-            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+            const closeAtaIx = (0, spl_token_1.createCloseAccountInstruction)(userSharesAta, user, user, [], spl_token_1.TOKEN_PROGRAM_ID);
             withdrawIxs.postWithdrawIxs.push(closeAtaIx);
         }
         return withdrawIxs;
@@ -751,8 +736,8 @@ class KaminoVaultClient {
     async withdrawFromAvailableIxs(user, vault, shareAmount) {
         const vaultState = await vault.getState(this.getConnection());
         const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
-        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
-        const [{ ata: userTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const [{ ata: userTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(user, [
             {
                 mint: vaultState.tokenMint,
                 tokenProgram: vaultState.tokenProgram,
@@ -765,8 +750,8 @@ class KaminoVaultClient {
     async withdrawWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
         const vaultState = await vault.getState(this.getConnection());
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
-        const [{ ata: userTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const [{ ata: userTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(user, [
             {
                 mint: vaultState.tokenMint,
                 tokenProgram: vaultState.tokenProgram,
@@ -785,7 +770,7 @@ class KaminoVaultClient {
         let isFirstWithdraw = true;
         if (tokenLeftToWithdraw.lte(0)) {
             // Availabe enough to withdraw all - using the first existent reserve
-            const firstReserve = vaultState.vaultAllocationStrategy.find((reserve) => reserve.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+            const firstReserve = vaultState.vaultAllocationStrategy.find((reserve) => !reserve.reserve.equals(web3_js_1.PublicKey.default));
             if (withdrawAllShares) {
                 reserveWithSharesAmountToWithdraw.push({
                     reserve: firstReserve.reserve,
@@ -831,7 +816,7 @@ class KaminoVaultClient {
             const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
             const reserveState = vaultReservesState.get(reserveWithTokens.reserve);
             if (reserveState === undefined) {
-                throw new Error(`Reserve ${reserveWithTokens.reserve} not found in vault reserves map`);
+                throw new Error(`Reserve ${reserveWithTokens.reserve.toBase58()} not found in vault reserves map`);
             }
             const marketAddress = reserveState.state.lendingMarket;
             const isLastWithdraw = reserveIndex === reserveWithSharesAmountToWithdraw.length - 1;
@@ -840,7 +825,7 @@ class KaminoVaultClient {
             if (isLastWithdraw) {
                 sharesToWithdraw = reserveWithTokens.shares;
             }
-            const withdrawFromReserveIx = await this.withdrawIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, sharesToWithdraw, vaultReservesState);
+            const withdrawFromReserveIx = this.withdrawIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, sharesToWithdraw, vaultReservesState);
             withdrawIxs.push(withdrawFromReserveIx);
         }
         return withdrawIxs;
@@ -863,7 +848,7 @@ class KaminoVaultClient {
             this.getVaultComputedReservesAllocation(vaultState),
         ]);
         const tokenProgram = await (0, rpc_1.getAccountOwner)(this.getConnection(), vaultState.tokenMint);
-        const [{ createAtaIx }] = await (0, utils_2.createAtasIdempotent)(payer, [
+        const [{ ata: _payerTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(payer, [
             { mint: vaultState.tokenMint, tokenProgram },
         ]);
         // compute total vault holdings and expected distribution based on weights
@@ -900,7 +885,7 @@ class KaminoVaultClient {
         for (const reserve of reservesToDisinvestFrom) {
             const reserveState = allReservesStateMap.get(reserve);
             if (reserveState === null) {
-                throw new Error(`Reserve ${reserve} not found`);
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
             }
             const investIxsPromise = this.investSingleReserveIxs(payer, vault, {
                 address: reserve,
@@ -911,7 +896,7 @@ class KaminoVaultClient {
         for (const reserve of reservesToInvestInto) {
             const reserveState = allReservesStateMap.get(reserve);
             if (reserveState === null) {
-                throw new Error(`Reserve ${reserve} not found`);
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
             }
             const investIxsPromise = this.investSingleReserveIxs(payer, vault, {
                 address: reserve,
@@ -927,21 +912,20 @@ class KaminoVaultClient {
     // todo: make sure we also check the ata of the investor for the vault token exists
     /**
      * 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
-     * @param payer wallet pubkey - the instruction is permissionless and does not require the vault admin, due to rounding between cTokens and the underlying, the payer may have to contribute 1 or more lamports of the underlying from their token account
+     * @param payer wallet pubkey
      * @param vault - vault to invest from
      * @param reserve - reserve to invest into or disinvest from
      * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
-     * @param [createAtaIfNeeded]
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
     async investSingleReserveIxs(payer, vault, reserve, vaultReservesMap, createAtaIfNeeded = true) {
-        console.log('create invest ix for reserve', reserve.address);
+        console.log('create invest ix for reserve', reserve.address.toBase58());
         const vaultState = await vault.getState(this.getConnection());
-        const cTokenVault = await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
-        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId);
+        const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
+        const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
         const ixs = [];
         const tokenProgram = await (0, rpc_1.getAccountOwner)(this.getConnection(), vaultState.tokenMint);
-        const [{ ata: payerTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(payer, [
+        const [{ ata: payerTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(payer, [
             { mint: vaultState.tokenMint, tokenProgram },
         ]);
         if (createAtaIfNeeded) {
@@ -960,16 +944,31 @@ class KaminoVaultClient {
             reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
             reserveCollateralMint: reserve.state.collateral.mintPubkey,
             klendProgram: this._kaminoLendProgramId,
-            instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
             tokenProgram: tokenProgram,
             payerTokenAccount: payerTokenAta,
             tokenMint: vaultState.tokenMint,
-            reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            reserveCollateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
-        let investIx = (0, instructions_1.invest)(investAccounts, this._kaminoVaultProgramId);
+        const investIx = (0, instructions_1.invest)(investAccounts, this._kaminoVaultProgramId);
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-        investIx = this.appendRemainingAccountsForVaultReserves(investIx, vaultReserves, vaultReservesState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
+        });
+        investIx.keys = investIx.keys.concat(vaultReservesAccountMetas);
+        investIx.keys = investIx.keys.concat(vaultReservesLendingMarkets);
         return [createAtaIx, investIx];
     }
     /** Convert a string to a u8 representation to be stored on chain */
@@ -983,9 +982,9 @@ class KaminoVaultClient {
     decodeVaultName(token) {
         return (0, utils_1.decodeVaultName)(token);
     }
-    async withdrawIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
-        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
-        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+    withdrawIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
+        const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId)[0];
+        const eventAuthority = getEventAuthorityPda(this._kaminoVaultProgramId);
         const withdrawAccounts = {
             withdrawFromAvailable: {
                 user,
@@ -997,7 +996,7 @@ class KaminoVaultClient {
                 userSharesAta: userSharesAta,
                 sharesMint: vaultState.sharesMint,
                 tokenProgram: vaultState.tokenProgram,
-                sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 klendProgram: this._kaminoLendProgramId,
                 eventAuthority: eventAuthority,
                 program: this._kaminoVaultProgramId,
@@ -1005,82 +1004,112 @@ class KaminoVaultClient {
             withdrawFromReserveAccounts: {
                 vaultState: vault.address,
                 reserve: reserve.address,
-                ctokenVault: await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
+                ctokenVault: getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
                 lendingMarket: marketAddress,
                 lendingMarketAuthority: lendingMarketAuth,
                 reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
                 reserveCollateralMint: reserve.state.collateral.mintPubkey,
-                reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
+                reserveCollateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
             },
             eventAuthority: eventAuthority,
             program: this._kaminoVaultProgramId,
         };
         const withdrawArgs = {
-            sharesAmount: new bn_js_1.default(shareAmountLamports.floor().toString()),
+            sharesAmount: new anchor_1.BN(shareAmountLamports.floor().toString()),
         };
-        let withdrawIxn = (0, instructions_1.withdraw)(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
+        const withdrawIxn = (0, instructions_3.withdraw)(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
         const vaultReserves = this.getVaultReserves(vaultState);
-        withdrawIxn = this.appendRemainingAccountsForVaultReserves(withdrawIxn, vaultReserves, vaultReservesState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
+        });
+        withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesAccountMetas);
+        withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesLendingMarkets);
         return withdrawIxn;
     }
     async withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareAmountLamports) {
-        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+        const eventAuthority = getEventAuthorityPda(this._kaminoVaultProgramId);
         const withdrawFromAvailableAccounts = {
             user,
             vaultState: vault.address,
             tokenVault: vaultState.tokenVault,
             baseVaultAuthority: vaultState.baseVaultAuthority,
-            userTokenAta,
+            userTokenAta: userTokenAta,
             tokenMint: vaultState.tokenMint,
-            userSharesAta,
+            userSharesAta: userSharesAta,
             sharesMint: vaultState.sharesMint,
             tokenProgram: vaultState.tokenProgram,
-            sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             klendProgram: this._kaminoLendProgramId,
-            eventAuthority,
+            eventAuthority: eventAuthority,
             program: this._kaminoVaultProgramId,
         };
         const withdrawFromAvailableArgs = {
-            sharesAmount: new bn_js_1.default(shareAmountLamports.floor().toString()),
+            sharesAmount: new anchor_1.BN(shareAmountLamports.floor().toString()),
         };
         return (0, instructions_1.withdrawFromAvailable)(withdrawFromAvailableArgs, withdrawFromAvailableAccounts, this._kaminoVaultProgramId);
     }
-    async withdrawPendingFeesIx(authority, vault, vaultState, marketAddress, reserve, adminTokenAta) {
-        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
+    async withdrawPendingFeesIx(vault, vaultState, marketAddress, reserve, adminTokenAta) {
+        const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId)[0];
         const withdrawPendingFeesAccounts = {
-            vaultAdminAuthority: authority,
+            vaultAdminAuthority: vaultState.vaultAdminAuthority,
             vaultState: vault.address,
             reserve: reserve.address,
             tokenVault: vaultState.tokenVault,
-            ctokenVault: await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
+            ctokenVault: getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
             baseVaultAuthority: vaultState.baseVaultAuthority,
             tokenAta: adminTokenAta,
             tokenMint: vaultState.tokenMint,
-            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             /** CPI accounts */
             lendingMarket: marketAddress,
             lendingMarketAuthority: lendingMarketAuth,
             reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
             reserveCollateralMint: reserve.state.collateral.mintPubkey,
             klendProgram: this._kaminoLendProgramId,
-            instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
-            reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            reserveCollateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
-        let withdrawPendingFeesIxn = (0, instructions_1.withdrawPendingFees)(withdrawPendingFeesAccounts, this._kaminoVaultProgramId);
+        const withdrawPendingFeesIxn = (0, instructions_1.withdrawPendingFees)(withdrawPendingFeesAccounts, this._kaminoVaultProgramId);
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = await this.loadVaultReserves(vaultState);
-        withdrawPendingFeesIxn = this.appendRemainingAccountsForVaultReserves(withdrawPendingFeesIxn, vaultReserves, vaultReservesState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
+        });
+        withdrawPendingFeesIxn.keys = withdrawPendingFeesIxn.keys.concat(vaultReservesAccountMetas);
+        withdrawPendingFeesIxn.keys = withdrawPendingFeesIxn.keys.concat(vaultReservesLendingMarkets);
         return withdrawPendingFeesIxn;
     }
     /**
      * Sync a vault for lookup table; create and set the LUT for the vault if needed and fill it with all the needed accounts
-     * @param authority - vault admin
      * @param vault the vault to sync and set the LUT for if needed
+     * @param vaultReserves optional; the state of the reserves in the vault allocation
      * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
      * @returns a struct that contains a list of ix to create the LUT and assign it to the vault if needed + a list of ixs to insert all the accounts in the LUT
      */
-    async syncVaultLookupTableIxs(authority, vault, vaultReservesMap) {
+    async syncVaultLookupTableIxs(vault, vaultReservesMap) {
         const vaultState = await vault.getState(this.getConnection());
         const allAccountsToBeInserted = [
             vault.address,
@@ -1119,14 +1148,14 @@ class KaminoVaultClient {
                 allAccountsToBeInserted.push(reserve.state.collateral.supplyVault);
             });
         }
-        if (vaultState.vaultFarm !== lib_1.DEFAULT_PUBLIC_KEY) {
+        if (!vaultState.vaultFarm.equals(web3_js_1.PublicKey.default)) {
             allAccountsToBeInserted.push(vaultState.vaultFarm);
         }
         const setupLUTIfNeededIxs = [];
         let lut = vaultState.vaultLookupTable;
-        if (lut === lib_1.DEFAULT_PUBLIC_KEY) {
-            const recentSlot = await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
-            const [ix, address] = await (0, lookupTable_1.initLookupTableIx)(authority, recentSlot);
+        if (lut.equals(web3_js_1.PublicKey.default)) {
+            const recentSlot = await this.getConnection().getSlot();
+            const [ix, address] = (0, lookupTable_1.initLookupTableIx)(vaultState.vaultAdminAuthority, recentSlot);
             setupLUTIfNeededIxs.push(ix);
             lut = address;
             // set the new LUT for the vault
@@ -1134,11 +1163,11 @@ class KaminoVaultClient {
             setupLUTIfNeededIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
         }
         const ixs = [];
-        let overriddenExistentAccounts = undefined;
-        if (vaultState.vaultLookupTable === lib_1.DEFAULT_PUBLIC_KEY) {
-            overriddenExistentAccounts = [];
+        let overridenExistentAccounts = undefined;
+        if (vaultState.vaultLookupTable.equals(web3_js_1.PublicKey.default)) {
+            overridenExistentAccounts = [];
         }
-        ixs.push(...(await this.insertIntoLookupTableIxs(authority, lut, allAccountsToBeInserted, overriddenExistentAccounts)));
+        ixs.push(...(await this.insertIntoLookupTableIxs(vaultState.vaultAdminAuthority, lut, allAccountsToBeInserted, overridenExistentAccounts)));
         return {
             setupLUTIfNeededIxs,
             syncLUTIxs: ixs,
@@ -1158,35 +1187,35 @@ class KaminoVaultClient {
     }
     /**
      * This method inserts the missing keys from the provided keys into an existent lookup table
-     * @param authority - payer wallet pubkey
+     * @param payer - payer wallet pubkey
      * @param lookupTable - lookup table to insert the keys into
      * @param keys - keys to insert into the lookup table
-     * @param [accountsInLut] - the existent accounts in the lookup table. Optional. If provided, the function will not fetch the accounts in the lookup table
+     * @param [accountsInLUT] - the existent accounts in the lookup table. Optional. If provided, the function will not fetch the accounts in the lookup table
      * @returns - an array of instructions to insert the missing keys into the lookup table
      */
-    async insertIntoLookupTableIxs(authority, lookupTable, keys, accountsInLut) {
-        let lutContentsList = accountsInLut;
-        if (!accountsInLut) {
-            lutContentsList = await (0, lookupTable_1.getAccountsInLut)(this.getConnection(), lookupTable);
+    async insertIntoLookupTableIxs(payer, lookupTable, keys, accountsInLUT) {
+        let lutContentsList = accountsInLUT;
+        if (!accountsInLUT) {
+            lutContentsList = await (0, lookupTable_1.getAccountsInLUT)(this.getConnection(), lookupTable);
         }
         else {
-            lutContentsList = accountsInLut;
+            lutContentsList = accountsInLUT;
         }
-        const lutContents = new Set(lutContentsList);
-        const missingAccounts = keys.filter((key) => !lutContents.has(key) && key !== lib_1.DEFAULT_PUBLIC_KEY);
+        const lutContents = new utils_2.PublicKeySet(lutContentsList);
+        const missingAccounts = keys.filter((key) => !lutContents.contains(key) && !key.equals(web3_js_1.PublicKey.default));
         // deduplicate missing accounts and remove default accounts and convert it back to an array
-        const missingAccountsList = [...new Set(missingAccounts)];
+        const missingAccountsList = new utils_2.PublicKeySet(missingAccounts).toArray();
         const chunkSize = 20;
         const ixs = [];
         for (let i = 0; i < missingAccountsList.length; i += chunkSize) {
             const chunk = missingAccountsList.slice(i, i + chunkSize);
-            ixs.push((0, address_lookup_table_1.getExtendLookupTableInstruction)({
-                payer: authority,
-                authority,
-                address: lookupTable,
-                systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
+            const ix = web3_js_1.AddressLookupTableProgram.extendLookupTable({
+                lookupTable,
+                authority: payer,
+                payer,
                 addresses: chunk,
-            }));
+            });
+            ixs.push(ix);
         }
         return ixs;
     }
@@ -1206,7 +1235,7 @@ class KaminoVaultClient {
             return allocation?.targetWeight.isZero();
         });
         if (allReservesPubkeys.length === 0 || allReservesHaveWeight0) {
-            const computedHoldings = new Map();
+            const computedHoldings = new lib_1.PubkeyHashMap();
             allReservesPubkeys.forEach((reserve) => {
                 computedHoldings.set(reserve, new decimal_js_1.default(0));
             });
@@ -1219,7 +1248,7 @@ class KaminoVaultClient {
         initialVaultAllocations.forEach((allocation) => {
             totalAllocation = totalAllocation.add(allocation.targetWeight);
         });
-        const expectedHoldingsDistribution = new Map();
+        const expectedHoldingsDistribution = new lib_1.PubkeyHashMap();
         allReserves.forEach((reserve) => {
             expectedHoldingsDistribution.set(reserve, new decimal_js_1.default(0));
         });
@@ -1264,10 +1293,10 @@ class KaminoVaultClient {
             stakedShares: new decimal_js_1.default(0),
             totalShares: new decimal_js_1.default(0),
         };
-        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
-        const userSharesAccountInfo = await (0, token_2022_1.fetchMaybeToken)(this.getConnection(), userSharesAta);
-        if (userSharesAccountInfo.exists) {
-            const userSharesAccount = userSharesAccountInfo.data;
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const userSharesAccountInfo = await this.getConnection().getAccountInfo(userSharesAta);
+        if (userSharesAccountInfo) {
+            const userSharesAccount = (0, spl_token_1.unpackAccount)(userSharesAta, userSharesAccountInfo);
             userShares.unstakedShares = new decimal_js_1.default(userSharesAccount.amount.toString()).div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
         }
         if (await vault.hasFarm(this.getConnection())) {
@@ -1286,26 +1315,26 @@ class KaminoVaultClient {
     async getUserSharesBalanceAllVaults(user, vaultsOverride) {
         const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
         // read all user shares stake in vault farms
-        const farmClient = new farms_sdk_1.Farms(this.getConnection());
+        const farmClient = new dist_1.Farms(this.getConnection());
         const allUserFarmStates = await farmClient.getAllUserStatesForUser(user);
-        const allUserFarmStatesMap = new Map();
+        const allUserFarmStatesMap = new lib_1.PubkeyHashMap();
         allUserFarmStates.forEach((userFarmState) => {
             allUserFarmStatesMap.set(userFarmState.userState.farmState, userFarmState.userState);
         });
         // stores vault address for each userSharesAta
-        const vaultUserShareBalance = new Map();
+        const vaultUserShareBalance = new lib_1.PubkeyHashMap();
         const userSharesAtaArray = [];
         vaults.forEach(async (vault) => {
             const state = vault.state;
             if (!state) {
-                throw new Error(`Vault ${vault.address} not fetched`);
+                throw new Error(`Vault ${vault.address.toBase58()} not fetched`);
             }
-            const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(state.sharesMint, user);
+            const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(state.sharesMint, user);
             userSharesAtaArray.push(userSharesAta);
             if (await vault.hasFarm(this.getConnection())) {
                 const userFarmState = allUserFarmStatesMap.get(state.vaultFarm);
                 if (userFarmState) {
-                    console.log('there is a farm state for vault', vault.address);
+                    console.log('there is a farm state for vault', vault.address.toBase58());
                     const stakedShares = (0, farm_utils_1.getSharesInFarmUserPosition)(userFarmState, state.sharesMintDecimals.toNumber());
                     console.log('staked shares', stakedShares);
                     const userSharesBalance = vaultUserShareBalance.get(vault.address);
@@ -1324,7 +1353,7 @@ class KaminoVaultClient {
                 }
             }
         });
-        const userSharesAtaAccounts = await (0, token_2022_1.fetchAllMaybeToken)(this.getConnection(), userSharesAtaArray);
+        const userSharesAtaAccounts = await this.getConnection().getMultipleAccountsInfo(userSharesAtaArray);
         userSharesAtaAccounts.forEach((userShareAtaAccount, index) => {
             let userSharesForVault = vaultUserShareBalance.get(vaults[index].address);
             if (!userSharesForVault) {
@@ -1334,11 +1363,11 @@ class KaminoVaultClient {
                     totalShares: new decimal_js_1.default(0),
                 };
             }
-            if (!userShareAtaAccount.exists) {
+            if (!userShareAtaAccount) {
                 vaultUserShareBalance.set(vaults[index].address, userSharesForVault);
             }
             else {
-                userSharesForVault.unstakedShares = new decimal_js_1.default(userShareAtaAccount.data.amount.toString()).div(new decimal_js_1.default(10).pow(vaults[index].state.sharesMintDecimals.toString()));
+                userSharesForVault.unstakedShares = (0, utils_1.getTokenBalanceFromAccountInfoLamports)(userShareAtaAccount).div(new decimal_js_1.default(10).pow(vaults[index].state.sharesMintDecimals.toString()));
                 userSharesForVault.totalShares = userSharesForVault.unstakedShares.add(userSharesForVault.stakedShares);
                 vaultUserShareBalance.set(vaults[index].address, userSharesForVault);
             }
@@ -1384,7 +1413,7 @@ class KaminoVaultClient {
      */
     async getTokensPerShareAllVaults(slot, vaultsOverride, vaultReservesMap) {
         const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
-        const vaultTokensPerShare = new Map();
+        const vaultTokensPerShare = new lib_1.PubkeyHashMap();
         for (const vault of vaults) {
             const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot, vaultReservesMap);
             vaultTokensPerShare.set(vault.address, tokensPerShare);
@@ -1398,13 +1427,12 @@ class KaminoVaultClient {
     async getAllVaults() {
         const filters = [
             {
-                dataSize: BigInt(accounts_1.VaultState.layout.span + 8),
+                dataSize: accounts_1.VaultState.layout.span + 8,
             },
             {
                 memcmp: {
-                    offset: 0n,
+                    offset: 0,
                     bytes: bs58_1.default.encode(accounts_1.VaultState.discriminator),
-                    encoding: 'base58',
                 },
             },
         ];
@@ -1418,33 +1446,37 @@ class KaminoVaultClient {
     async getAllVaultsForToken(token) {
         const filters = [
             {
-                dataSize: BigInt(accounts_1.VaultState.layout.span + 8),
+                dataSize: accounts_1.VaultState.layout.span + 8,
             },
             {
                 memcmp: {
-                    offset: 0n,
+                    offset: 0,
                     bytes: bs58_1.default.encode(accounts_1.VaultState.discriminator),
-                    encoding: 'base58',
                 },
             },
             {
                 memcmp: {
-                    offset: 80n, // tokenMint offset: 8 + 32 + 32 + 8 (discriminator + vaultAdminAuthority + baseVaultAuthority + baseVaultAuthorityBump)
-                    bytes: token.toString(),
-                    encoding: 'base58',
+                    offset: 80, // tokenMint offset: 8 + 32 + 32 + 8 (discriminator + vaultAdminAuthority + baseVaultAuthority + baseVaultAuthorityBump)
+                    bytes: token.toBase58(),
                 },
             },
         ];
         return await this.getAllVaultsWithFilter(filters);
     }
     async getAllVaultsWithFilter(filters) {
-        const kaminoVaults = await (0, rpc_1.getProgramAccounts)(this.getConnection(), this._kaminoVaultProgramId, accounts_1.VaultState.layout.span + 8, filters);
+        const kaminoVaults = await (0, rpc_1.getProgramAccounts)(this.getConnection(), this._kaminoVaultProgramId, accounts_1.VaultState.layout.span + 8, {
+            commitment: this.getConnection().commitment ?? 'processed',
+            filters,
+        });
         return kaminoVaults.map((kaminoVault) => {
-            const kaminoVaultAccount = (0, vault_1.decodeVaultState)(kaminoVault.data);
+            if (kaminoVault.account === null) {
+                throw new Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} does not exist`);
+            }
+            const kaminoVaultAccount = (0, vault_1.decodeVaultState)(kaminoVault.account.data);
             if (!kaminoVaultAccount) {
-                throw Error(`kaminoVault with pubkey ${kaminoVault.address} could not be decoded`);
+                throw Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} could not be decoded`);
             }
-            return new KaminoVault(kaminoVault.address, kaminoVaultAccount, this._kaminoVaultProgramId);
+            return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
         });
     }
     /**
@@ -1467,7 +1499,7 @@ class KaminoVaultClient {
     }
     /**
      * This will return the amount of token invested from the vault into the given reserve
-     * @param vaultState - the kamino vault to get invested amount in reserve for
+     * @param vault - the kamino vault to get invested amount in reserve for
      * @param slot - current slot
      * @param reserve - the reserve state to get vault invested amount in
      * @returns vault amount supplied in reserve in decimal
@@ -1483,9 +1515,9 @@ class KaminoVaultClient {
                 .toNumber();
         }
         const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, referralFeeBps);
-        const reserveAllocation = vaultState.vaultAllocationStrategy.find((allocation) => allocation.reserve === reserve.address);
+        const reserveAllocation = vaultState.vaultAllocationStrategy.find((allocation) => allocation.reserve.equals(reserve.address));
         if (!reserveAllocation) {
-            throw new Error(`Reserve ${reserve.address} not found in vault allocation strategy`);
+            throw new Error(`Reserve ${reserve.address.toBase58()} not found in vault allocation strategy`);
         }
         const reserveAllocationLiquidityAmountLamports = new decimal_js_1.default(reserveAllocation.ctokenAllocation.toString()).div(reserveCollExchangeRate);
         const reserveAllocationLiquidityAmount = (0, lib_1.lamportsToDecimal)(reserveAllocationLiquidityAmountLamports, vaultState.tokenMintDecimals.toNumber());
@@ -1497,9 +1529,9 @@ class KaminoVaultClient {
      * @returns a map between reserve pubkey and the allocation pct for the reserve
      */
     getAllocationsDistribuionPct(vaultState) {
-        const allocationsDistributionPct = new Map();
+        const allocationsDistributionPct = new lib_1.PubkeyHashMap();
         let totalAllocation = new decimal_js_1.default(0);
-        const filteredAllocations = vaultState.vaultAllocationStrategy.filter((allocation) => allocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        const filteredAllocations = vaultState.vaultAllocationStrategy.filter((allocation) => !allocation.reserve.equals(web3_js_1.PublicKey.default));
         filteredAllocations.forEach((allocation) => {
             totalAllocation = totalAllocation.add(new decimal_js_1.default(allocation.targetAllocationWeight.toString()));
         });
@@ -1514,9 +1546,9 @@ class KaminoVaultClient {
      * @returns a map between reserve pubkey and the allocation overview for the reserve
      */
     getVaultAllocations(vaultState) {
-        const vaultAllocations = new Map();
+        const vaultAllocations = new lib_1.PubkeyHashMap();
         vaultState.vaultAllocationStrategy.map((allocation) => {
-            if (allocation.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocation.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const allocationOverview = {
@@ -1537,14 +1569,14 @@ class KaminoVaultClient {
      */
     async getReserveAllocationAvailableLiquidityToWithdraw(vault, slot, vaultReservesMap) {
         const vaultState = await vault.getState(this.getConnection());
-        const reserveAllocationAvailableLiquidityToWithdraw = new Map();
+        const reserveAllocationAvailableLiquidityToWithdraw = new lib_1.PubkeyHashMap();
         vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesMap.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             let referralFeeBps = 0;
             const denominator = reserve.state.config.protocolTakeRatePct / 100;
@@ -1569,7 +1601,7 @@ class KaminoVaultClient {
      */
     getVaultReserves(vault) {
         return vault.vaultAllocationStrategy
-            .filter((vaultAllocation) => vaultAllocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY)
+            .filter((vaultAllocation) => !vaultAllocation.reserve.equals(web3_js_1.PublicKey.default))
             .map((vaultAllocation) => vaultAllocation.reserve);
     }
     /**
@@ -1586,29 +1618,27 @@ class KaminoVaultClient {
      * @returns a hashmap from each reserve pubkey to the reserve state
      */
     async loadVaultsReserves(vaults) {
-        const vaultReservesAddressesSet = new Set(vaults.flatMap((vault) => this.getVaultReserves(vault)));
-        const vaultReservesAddresses = [...vaultReservesAddressesSet];
-        const reserveAccounts = await this.getConnection()
-            .getMultipleAccounts(vaultReservesAddresses, { commitment: 'processed' })
-            .send();
-        const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
+        const vaultReservesAddressesSet = new utils_2.PublicKeySet(vaults.flatMap((vault) => this.getVaultReserves(vault)));
+        const vaultReservesAddresses = vaultReservesAddressesSet.toArray();
+        const reserveAccounts = await this.getConnection().getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
+        const deserializedReserves = reserveAccounts.map((reserve, i) => {
             if (reserve === null) {
                 // maybe reuse old here
-                throw new Error(`Reserve account ${vaultReservesAddresses[i]} was not found`);
+                throw new Error(`Reserve account ${vaultReservesAddresses[i].toBase58()} was not found`);
             }
-            const reserveAccount = lib_1.Reserve.decode(Buffer.from(reserve.data[0], 'base64'));
+            const reserveAccount = lib_1.Reserve.decode(reserve.data);
             if (!reserveAccount) {
-                throw Error(`Could not parse reserve ${vaultReservesAddresses[i]}`);
+                throw Error(`Could not parse reserve ${vaultReservesAddresses[i].toBase58()}`);
             }
             return reserveAccount;
         });
         const reservesAndOracles = await (0, lib_1.getTokenOracleData)(this.getConnection(), deserializedReserves);
-        const kaminoReserves = new Map();
+        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(vaultReservesAddresses[index], reserve, oracle, this.getConnection(), this.recentSlotDurationMs);
+            const kaminoReserve = lib_1.KaminoReserve.initialize(reserveAccounts[index], vaultReservesAddresses[index], reserve, oracle, this.getConnection(), this.recentSlotDurationMs);
             kaminoReserves.set(kaminoReserve.address, kaminoReserve);
         });
         return kaminoReserves;
@@ -1624,10 +1654,10 @@ class KaminoVaultClient {
     async getVaultCollaterals(vaultState, slot, vaultReservesMap, kaminoMarkets) {
         const vaultReservesStateMap = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
         const vaultReservesState = [];
-        const missingReserves = new Set([]);
+        const missingReserves = new utils_2.PublicKeySet([]);
         // filter the reserves that are not part of the vault allocation strategy
         vaultState.vaultAllocationStrategy.forEach(async (allocation) => {
-            if (allocation.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocation.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesStateMap.get(allocation.reserve);
@@ -1638,24 +1668,23 @@ class KaminoVaultClient {
             vaultReservesState.push(reserve);
         });
         // read missing reserves
-        const missingReservesStates = (await lib_1.Reserve.fetchMultiple(this.getConnection(), [...missingReserves])).filter((reserve) => reserve !== null);
+        const missingReservesStates = (await lib_1.Reserve.fetchMultiple(this.getConnection(), missingReserves.toArray())).filter((reserve) => reserve !== null);
         const missingReservesAndOracles = await (0, lib_1.getTokenOracleData)(this.getConnection(), missingReservesStates);
         missingReservesAndOracles.forEach(([reserve, oracle], index) => {
-            const fetchedReserve = new lib_1.KaminoReserve(reserve, [...missingReserves][index], // Set maintains order
-            oracle, this.getConnection(), this.recentSlotDurationMs);
+            const fetchedReserve = new lib_1.KaminoReserve(reserve, missingReserves.toArray()[index], oracle, this.getConnection(), this.recentSlotDurationMs);
             vaultReservesState.push(fetchedReserve);
         });
-        const vaultCollateralsPerReserve = new Map();
+        const vaultCollateralsPerReserve = new lib_1.PubkeyHashMap();
         for (const reserve of vaultReservesState) {
             // try to read the market from the provided list, if it doesn't exist fetch it
             let lendingMarket = undefined;
             if (kaminoMarkets) {
-                lendingMarket = kaminoMarkets?.find((market) => reserve.state.lendingMarket === market.address);
+                lendingMarket = kaminoMarkets?.find((market) => reserve.state.lendingMarket.equals(new web3_js_1.PublicKey(market.address)));
             }
             if (!lendingMarket) {
-                const fetchedLendingMarket = await lib_1.KaminoMarket.load(this.getConnection(), reserve.state.lendingMarket, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS);
+                const fetchedLendingMarket = await lib_1.KaminoMarket.load(this.getConnection(), reserve.state.lendingMarket, slot);
                 if (!fetchedLendingMarket) {
-                    throw Error(`Could not fetch lending market ${reserve.state.lendingMarket}`);
+                    throw Error(`Could not fetch lending market ${reserve.state.lendingMarket.toBase58()}`);
                 }
                 lendingMarket = fetchedLendingMarket;
             }
@@ -1669,7 +1698,7 @@ class KaminoVaultClient {
             marketReserves
                 .filter((marketReserve) => {
                 return (marketReserve.state.config.liquidationThresholdPct > 0 &&
-                    marketReserve.address !== reserve.address &&
+                    !marketReserve.address.equals(reserve.address) &&
                     marketReserve.state.config.status === 0);
             })
                 .map((filteredReserve) => {
@@ -1702,20 +1731,20 @@ class KaminoVaultClient {
         const vaultHoldings = {
             available: new decimal_js_1.default(vault.tokenAvailable.toString()),
             invested: new decimal_js_1.default(0),
-            investedInReserves: new Map(),
+            investedInReserves: new lib_1.PubkeyHashMap(),
             totalAUMIncludingFees: new decimal_js_1.default(0),
             pendingFees: new decimal_js_1.default(0),
         };
-        const currentSlotToUse = currentSlot ?? (await this.getConnection().getSlot({ commitment: 'confirmed' }).send());
+        const currentSlotToUse = currentSlot ? currentSlot : await this.getConnection().getSlot('confirmed');
         const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
         const decimals = new decimal_js_1.default(vault.tokenMintDecimals.toString());
         vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesState.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             let reserveCollExchangeRate;
             if (slot) {
@@ -1733,7 +1762,7 @@ class KaminoVaultClient {
         // if there is a slot passed and it is in the future we need to estimate the fees from current time until that moment
         if (slot && slot > currentSlotToUse) {
             const currentTimestampSec = new Date().getTime() / 1000;
-            const timeAtPassedSlot = currentTimestampSec + Number.parseInt((slot - currentSlotToUse).toString()) * this.recentSlotDurationMs;
+            const timeAtPassedSlot = currentTimestampSec + (slot - currentSlotToUse) * this.recentSlotDurationMs;
             const timeUntilPassedSlot = timeAtPassedSlot - currentTimestampSec;
             const managementFeeFactor = new decimal_js_1.default(timeUntilPassedSlot)
                 .mul(new decimal_js_1.default(vault.managementFeeBps.toString()))
@@ -1773,7 +1802,7 @@ class KaminoVaultClient {
      */
     async getVaultHoldingsWithPrice(vault, price, slot, vaultReservesMap, currentSlot) {
         const holdings = await this.getVaultHoldings(vault, slot, vaultReservesMap, currentSlot);
-        const investedInReservesUSD = new Map();
+        const investedInReservesUSD = new lib_1.PubkeyHashMap();
         holdings.investedInReserves.forEach((amount, reserve) => {
             investedInReservesUSD.set(reserve, amount.mul(price));
         });
@@ -1799,7 +1828,7 @@ class KaminoVaultClient {
     async getVaultOverview(vault, price, slot, vaultReservesMap, kaminoMarkets, currentSlot) {
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
         const vaultHoldingsWithUSDValuePromise = await this.getVaultHoldingsWithPrice(vault, price, slot, vaultReservesState, currentSlot);
-        const slotForOverview = slot ? slot : await this.getConnection().getSlot().send();
+        const slotForOverview = slot ? slot : await this.getConnection().getSlot();
         const vaultTheoreticalAPYPromise = await this.getVaultTheoreticalAPY(vault, slotForOverview, vaultReservesState);
         const vaultActualAPYPromise = await this.getVaultActualAPY(vault, slotForOverview, vaultReservesState);
         const totalInvestedAndBorrowedPromise = await this.getTotalBorrowedAndInvested(vault, slotForOverview, vaultReservesState);
@@ -1840,12 +1869,12 @@ class KaminoVaultClient {
         let totalInvested = new decimal_js_1.default(0);
         let totalBorrowed = new decimal_js_1.default(0);
         vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesState.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0);
             const reserveAllocationLiquidityAmountLamports = new decimal_js_1.default(allocationStrategy.ctokenAllocation.toString()).div(reserveCollExchangeRate);
@@ -1873,14 +1902,14 @@ class KaminoVaultClient {
      */
     async getVaultReservesDetails(vault, slot, vaultReserves) {
         const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
-        const reservesDetails = new Map();
+        const reservesDetails = new lib_1.PubkeyHashMap();
         vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesState.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             const suppliedInReserve = this.getSuppliedInReserve(vault, slot, reserve);
             const utilizationRatio = new decimal_js_1.default(reserve.getEstimatedUtilizationRatio(slot, 0));
@@ -1909,12 +1938,12 @@ class KaminoVaultClient {
         let totalWeights = new decimal_js_1.default(0);
         let totalAPY = new decimal_js_1.default(0);
         vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesState.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             const reserveAPY = new decimal_js_1.default(reserve.totalSupplyAPY(slot));
             const weight = new decimal_js_1.default(allocationStrategy.targetAllocationWeight.toString());
@@ -1949,12 +1978,12 @@ class KaminoVaultClient {
         let totalAUM = new decimal_js_1.default(vault.tokenAvailable.toString());
         let totalAPY = new decimal_js_1.default(0);
         vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
-            if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
+            if (allocationStrategy.reserve.equals(web3_js_1.PublicKey.default)) {
                 return;
             }
             const reserve = vaultReservesState.get(allocationStrategy.reserve);
             if (reserve === undefined) {
-                throw new Error(`Reserve ${allocationStrategy.reserve} not found`);
+                throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
             }
             const reserveAPY = new decimal_js_1.default(reserve.totalSupplyAPY(slot));
             const exchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0);
@@ -2011,7 +2040,7 @@ class KaminoVaultClient {
             prevAUM = (0, lib_1.lamportsToDecimal)(new fraction_1.Fraction(vaultState.prevAumSf).toDecimal(), tokenDecimals);
             pendingFees = (0, lib_1.lamportsToDecimal)(new fraction_1.Fraction(vaultState.pendingFeesSf).toDecimal(), tokenDecimals);
         }
-        const latestSlot = slot ? slot : await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
+        const latestSlot = slot ? slot : await this.getConnection().getSlot('confirmed');
         const currentHoldings = await this.getVaultHoldings(vaultState, latestSlot, vaultReservesMap, currentSlot);
         const earnedInterest = currentHoldings.totalAUMIncludingFees.sub(prevAUM).sub(pendingFees);
         return {
@@ -2045,29 +2074,8 @@ class KaminoVaultClient {
             performanceFee: performanceFee,
         };
     }
-    computeUserFarmStateDelegateePDAForUserInVault(farmsProgramId, vault, reserve, user) {
-        return (0, kit_1.getProgramDerivedAddress)({
-            seeds: [addressEncoder.encode(vault), addressEncoder.encode(reserve), addressEncoder.encode(user)],
-            programAddress: farmsProgramId,
-        });
-    }
-    appendRemainingAccountsForVaultReserves(ix, vaultReserves, vaultReservesState) {
-        let vaultReservesAccountMetas = [];
-        let vaultReservesLendingMarkets = [];
-        vaultReserves.forEach((reserve) => {
-            const reserveState = vaultReservesState.get(reserve);
-            if (reserveState === undefined) {
-                throw new Error(`Reserve ${reserve} not found`);
-            }
-            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([{ address: reserve, role: kit_1.AccountRole.WRITABLE }]);
-            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
-                { address: reserveState.state.lendingMarket, role: kit_1.AccountRole.READONLY },
-            ]);
-        });
-        return {
-            ...ix,
-            accounts: ix.accounts?.concat([...vaultReservesAccountMetas, ...vaultReservesLendingMarkets]),
-        };
+    computeUserFarmStateDelegateePDAForUserInVault(farmProgramID, vault, reserve, user) {
+        return web3_js_1.PublicKey.findProgramAddressSync([vault.toBuffer(), reserve.toBuffer(), user.toBuffer()], farmProgramID);
     }
 } // KaminoVaultClient
 exports.KaminoVaultClient = KaminoVaultClient;
@@ -2080,9 +2088,9 @@ class KaminoVault {
         this.state = state;
         this.programId = programId;
     }
-    async getState(rpc) {
+    async getState(connection) {
         if (!this.state) {
-            const res = await accounts_1.VaultState.fetch(rpc, this.address, this.programId);
+            const res = await accounts_1.VaultState.fetch(connection, this.address, this.programId);
             if (!res) {
                 throw new Error('Invalid vault');
             }
@@ -2093,16 +2101,16 @@ class KaminoVault {
             return this.state;
         }
     }
-    async reloadState(rpc) {
-        this.state = await accounts_1.VaultState.fetch(rpc, this.address, this.programId);
+    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;
     }
-    async hasFarm(rpc) {
-        const state = await this.getState(rpc);
-        return state.vaultFarm !== lib_1.DEFAULT_PUBLIC_KEY;
+    async hasFarm(connection) {
+        const state = await this.getState(connection);
+        return !state.vaultFarm.equals(web3_js_1.PublicKey.default);
     }
 }
 exports.KaminoVault = KaminoVault;
@@ -2164,27 +2172,11 @@ class ReserveAllocationConfig {
     }
 }
 exports.ReserveAllocationConfig = ReserveAllocationConfig;
-async function getCTokenVaultPda(vaultAddress, reserveAddress, kaminoVaultProgramId) {
-    return (await (0, kit_1.getProgramDerivedAddress)({
-        seeds: [
-            Buffer.from(CTOKEN_VAULT_SEED),
-            addressEncoder.encode(vaultAddress),
-            addressEncoder.encode(reserveAddress),
-        ],
-        programAddress: kaminoVaultProgramId,
-    }))[0];
-}
-async function getEventAuthorityPda(kaminoVaultProgramId) {
-    return (await (0, kit_1.getProgramDerivedAddress)({
-        seeds: [Buffer.from(EVENT_AUTHORITY_SEED)],
-        programAddress: kaminoVaultProgramId,
-    }))[0];
-}
-function parseVaultAdmin(vault, signer) {
-    return signer ?? (0, signer_1.noopSigner)(vault.vaultAdminAuthority);
+function getCTokenVaultPda(vaultAddress, reserveAddress, kaminoVaultProgramId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(CTOKEN_VAULT_SEED), vaultAddress.toBytes(), reserveAddress.toBytes()], kaminoVaultProgramId)[0];
 }
-function parseVaultPendingAdmin(vault, signer) {
-    return signer ?? (0, signer_1.noopSigner)(vault.pendingAdmin);
+function getEventAuthorityPda(kaminoVaultProgramId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(EVENT_AUTHORITY_SEED)], kaminoVaultProgramId)[0];
 }
 function printHoldings(holdings) {
     console.log('Holdings:');