@kamino-finance/klend-sdk 6.1.0-beta.0 → 7.0.1

package/dist/classes/manager.js

@@ -1,78 +1,50 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MARKET_UPDATER = exports.KaminoManager = void 0;
-const web3_js_1 = require("@solana/web3.js");
+const kit_1 = require("@solana/kit");
 const vault_1 = require("./vault");
 const lib_1 = require("../lib");
-const programId_1 = require("../idl_codegen/programId");
+const programId_1 = require("../@codegen/klend/programId");
 const scope_sdk_1 = require("@kamino-finance/scope-sdk");
+const TokenMetadatas_1 = require("@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/TokenMetadatas");
 const bn_js_1 = __importDefault(require("bn.js"));
-const types_1 = require("../idl_codegen/types");
+const types_1 = require("../@codegen/klend/types");
 const decimal_js_1 = __importDefault(require("decimal.js"));
-const anchor = __importStar(require("@coral-xyz/anchor"));
-const accounts_1 = require("../idl_codegen_kamino_vault/accounts");
-const spl_token_1 = require("@solana/spl-token");
-const bs58_1 = __importDefault(require("bs58"));
+const accounts_1 = require("../@codegen/kvault/accounts");
 const rpc_1 = require("../utils/rpc");
-const types_2 = require("../idl_codegen_kamino_vault/types");
-const sbv2_lite_1 = __importDefault(require("@switchboard-xyz/sbv2-lite"));
+const types_2 = require("../@codegen/kvault/types");
+const dist_1 = require("@kamino-finance/farms-sdk/dist");
 const multisig_1 = require("../utils/multisig");
 const vault_2 = require("../utils/vault");
+const signer_1 = require("../utils/signer");
+const system_1 = require("@solana-program/system");
+const sysvars_1 = require("@solana/sysvars");
+const token_1 = require("@solana-program/token");
 const configItems_1 = require("./configItems");
+const apy_1 = require("@kamino-finance/farms-sdk/dist/utils/apy");
+const accounts_2 = require("@kamino-finance/scope-sdk/dist/@codegen/scope/accounts");
+const base58Decoder = (0, kit_1.getBase58Decoder)();
 /**
  * KaminoManager is a class that provides a high-level interface to interact with the Kamino Lend and Kamino Vault programs, in order to create and manage a market, as well as vaults
  */
 class KaminoManager {
-    _connection;
+    _rpc;
     _kaminoVaultProgramId;
     _kaminoLendProgramId;
     _vaultClient;
     recentSlotDurationMs;
-    constructor(connection, recentSlotDurationMs, kaminoLendProgramId, kaminoVaultProgramId) {
-        this._connection = connection;
+    constructor(rpc, recentSlotDurationMs, kaminoLendProgramId, kaminoVaultProgramId) {
+        this._rpc = rpc;
         this.recentSlotDurationMs = recentSlotDurationMs;
         this._kaminoVaultProgramId = kaminoVaultProgramId ? kaminoVaultProgramId : vault_1.kaminoVaultId;
         this._kaminoLendProgramId = kaminoLendProgramId ? kaminoLendProgramId : programId_1.PROGRAM_ID;
-        this._vaultClient = new vault_1.KaminoVaultClient(connection, this.recentSlotDurationMs, this._kaminoVaultProgramId, this._kaminoLendProgramId);
+        this._vaultClient = new vault_1.KaminoVaultClient(rpc, this.recentSlotDurationMs, this._kaminoVaultProgramId, this._kaminoLendProgramId);
     }
-    getConnection() {
-        return this._connection;
+    getRpc() {
+        return this._rpc;
     }
     getProgramID() {
         return this._kaminoVaultProgramId;
@@ -84,23 +56,23 @@ class KaminoManager {
      * @returns ixs - an array of ixs for creating and initializing the market account
      */
     async createMarketIxs(params) {
-        const marketAccount = web3_js_1.Keypair.generate();
-        const size = lib_1.LendingMarket.layout.span + 8;
-        const [lendingMarketAuthority, _] = (0, lib_1.lendingMarketAuthPda)(marketAccount.publicKey, this._kaminoLendProgramId);
+        const marketAccount = await (0, kit_1.generateKeyPairSigner)();
+        const size = BigInt(lib_1.LendingMarket.layout.span + 8);
+        const [lendingMarketAuthority] = await (0, lib_1.lendingMarketAuthPda)(marketAccount.address, this._kaminoLendProgramId);
         const createMarketIxs = [];
-        createMarketIxs.push(web3_js_1.SystemProgram.createAccount({
-            fromPubkey: params.admin,
-            newAccountPubkey: marketAccount.publicKey,
-            lamports: await this._connection.getMinimumBalanceForRentExemption(size),
+        createMarketIxs.push((0, system_1.getCreateAccountInstruction)({
+            payer: params.admin,
+            newAccount: marketAccount,
             space: size,
-            programId: this._kaminoLendProgramId,
+            lamports: await this._rpc.getMinimumBalanceForRentExemption(size).send(),
+            programAddress: this._kaminoLendProgramId,
         }));
         const accounts = {
             lendingMarketOwner: params.admin,
-            lendingMarket: marketAccount.publicKey,
+            lendingMarket: marketAccount.address,
             lendingMarketAuthority: lendingMarketAuthority,
-            systemProgram: web3_js_1.SystemProgram.programId,
-            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
+            rent: sysvars_1.SYSVAR_RENT_ADDRESS,
         };
         const args = {
             quoteCurrency: Array(32).fill(0),
@@ -117,14 +89,14 @@ class KaminoManager {
      * @returns txnIxs - an array of arrays of ixs -> first array for reserve creation, second for updating it with correct params
      */
     async addAssetToMarketIxs(params) {
-        const market = await lib_1.LendingMarket.fetch(this._connection, params.marketAddress, this._kaminoLendProgramId);
+        const market = await lib_1.LendingMarket.fetch(this._rpc, params.marketAddress, this._kaminoLendProgramId);
         if (!market) {
             throw new Error('Market not found');
         }
         const marketWithAddress = { address: params.marketAddress, state: market };
-        const reserveAccount = web3_js_1.Keypair.generate();
-        const createReserveInstructions = await (0, lib_1.createReserveIxs)(this._connection, params.admin, params.adminLiquiditySource, params.marketAddress, params.assetConfig.mint, reserveAccount.publicKey, this._kaminoLendProgramId);
-        const updateReserveInstructions = await this.updateReserveIxs(marketWithAddress, reserveAccount.publicKey, params.assetConfig.getReserveConfig(), undefined, false);
+        const reserveAccount = await (0, kit_1.generateKeyPairSigner)();
+        const createReserveInstructions = await (0, lib_1.createReserveIxs)(this._rpc, params.admin, params.adminLiquiditySource, params.marketAddress, params.assetConfig.mint, params.assetConfig.mintTokenProgram, reserveAccount, this._kaminoLendProgramId);
+        const updateReserveInstructions = await this.updateReserveIxs(params.admin, marketWithAddress, reserveAccount.address, params.assetConfig.getReserveConfig(), undefined, false);
         const txnIxs = [];
         txnIxs.push(createReserveInstructions);
         txnIxs.push(updateReserveInstructions);
@@ -140,14 +112,15 @@ class KaminoManager {
     }
     /**
      * This method creates an instruction to set the shares metadata for a vault
+     * @param authority - the vault admin
      * @param vault - the vault to set the shares metadata for
      * @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(vault, tokenName, extraName) {
-        const vaultState = await vault.getState(this._connection);
-        return this._vaultClient.getSetSharesMetadataIx(this._connection, vaultState.vaultAdminAuthority, vault.address, vaultState.sharesMint, vaultState.baseVaultAuthority, tokenName, extraName);
+    async getSetSharesMetadataIx(authority, vault, tokenName, extraName) {
+        const vaultState = await vault.getState(this._rpc);
+        return this._vaultClient.getSetSharesMetadataIx(this._rpc, authority, vault.address, vaultState.sharesMint, vaultState.baseVaultAuthority, tokenName, extraName);
     }
     /**
      * 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.
@@ -159,24 +132,75 @@ class KaminoManager {
     async updateVaultReserveAllocationIxs(vault, reserveAllocationConfig, signer) {
         return this._vaultClient.updateReserveAllocationIxs(vault, reserveAllocationConfig, signer);
     }
+    /**
+     * This method updates the unallocated weight and cap of a vault (both are optional, if not provided the current values will be used)
+     * @param vault - the vault to update the unallocated weight and cap for
+     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
+     * @param [unallocatedWeight] - the new unallocated weight to set. If not provided, the current unallocated weight will be used
+     * @param [unallocatedCap] - the new unallocated cap to set. If not provided, the current unallocated cap will be used
+     * @returns - a list of instructions to update the unallocated weight and cap
+     */
+    async updateVaultUnallocatedWeightAndCapIxs(vault, vaultAdminAuthority, unallocatedWeight, unallocatedCap) {
+        return this._vaultClient.updateVaultUnallocatedWeightAndCapIxs(vault, vaultAdminAuthority, unallocatedWeight, unallocatedCap);
+    }
     /**
      * 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) {
-        return this._vaultClient.removeReserveFromAllocationIx(vault, reserve);
+    async removeReserveFromAllocationIx(vault, reserve, vaultAdminAuthority) {
+        return this._vaultClient.removeReserveFromAllocationIx(vault, reserve, vaultAdminAuthority);
+    }
+    /**
+     * This method sets weight to 0, remove tokens and remove from allocation a reserve from the vault
+     * @param signer - signer to use for the transaction
+     * @param kaminoVault - vault to remove the reserve from
+     * @param reserveAddress - reserve to remove from the vault allocation strategy
+     * @param [reserveState] - optional parameter to pass a reserve state. If not provided, the reserve will be fetched from the connection
+     * @returns - an array of instructions to set the reserve allocation to 0, invest the reserve if it has tokens, and remove the reserve from the allocation
+     */
+    async fullRemoveReserveFromVaultIxs(signer, kaminoVault, reserveAddress, reserveState) {
+        const connection = this.getRpc();
+        const vaultState = await kaminoVault.getState(connection);
+        const allocations = this.getVaultReserves(vaultState);
+        if (!allocations.includes(reserveAddress)) {
+            throw new Error('Reserve not found in vault allocations');
+        }
+        const fetchedReserveState = reserveState ?? (await lib_1.Reserve.fetch(connection, reserveAddress, this._kaminoLendProgramId));
+        if (!fetchedReserveState) {
+            throw new Error('Reserve not found');
+        }
+        const reserveWithAddress = {
+            address: reserveAddress,
+            state: fetchedReserveState,
+        };
+        const kaminoReserve = await lib_1.KaminoReserve.initializeFromAddress(reserveAddress, connection, this.recentSlotDurationMs, reserveState);
+        const reserveAllocationConfig = new vault_1.ReserveAllocationConfig(reserveWithAddress, 0, new decimal_js_1.default(0));
+        const setAllocationToZeroIx = await this.updateVaultReserveAllocationIxs(kaminoVault, reserveAllocationConfig, signer);
+        const investIx = await this.investSingleReserveIxs(signer, kaminoVault, reserveWithAddress);
+        const removeAllocationIx = await this.removeReserveFromAllocationIx(kaminoVault, reserveAddress, signer);
+        const ixs = [setAllocationToZeroIx.updateReserveAllocationIx];
+        const slot = await connection.getSlot({ commitment: 'confirmed' }).send();
+        const suppliedInReserve = this.getSuppliedInReserve(vaultState, slot, kaminoReserve);
+        if (suppliedInReserve.gt(new decimal_js_1.default(0))) {
+            ixs.push(...investIx);
+        }
+        if (removeAllocationIx) {
+            ixs.push(removeAllocationIx);
+        }
+        return ixs;
     }
     /**
      * 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 payer - the payer of the transaction. If not provided, the admin of the vault will be used
+     * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
      * @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, payer) {
-        return this._vaultClient.withdrawEverythingAndBlockInvestReserve(vault, reserve, payer);
+    async withdrawEverythingAndBlockInvestReserve(vault, reserve, vaultAdminAuthority) {
+        return this._vaultClient.withdrawEverythingAndBlockInvestReserve(vault, reserve, vaultAdminAuthority);
     }
     /**
      * This method withdraws all the funds from all the reserves and blocks them from being invested by setting their weight and ctoken allocation to 0
@@ -188,6 +212,16 @@ class KaminoManager {
     async withdrawEverythingFromAllReservesAndBlockInvest(vault, vaultReservesMap, payer) {
         return this._vaultClient.withdrawEverythingFromAllReservesAndBlockInvest(vault, vaultReservesMap, payer);
     }
+    /**
+     * This method disinvests all the funds from all the reserves and set their weight to 0; for vaults that are managed by external bot/crank, the bot can change the weight and invest in the reserves again
+     * @param vault - the vault to disinvest the invested funds from
+     * @param [vaultReservesMap] - optional parameter to pass a map of the vault reserves. If not provided, the reserves will be loaded from the vault
+     * @param [payer] - optional parameter to pass a different payer for the transaction. If not provided, the admin of the vault will be used; this is the payer for the invest ixs and it should have an ATA and some lamports (2x no_of_reserves) of the token vault
+     * @returns - a struct with an instruction to update the reserve allocations to 0 weight and a list of instructions to disinvest the funds in the reserves
+     */
+    async disinvestAllReservesIxs(vault, vaultReservesMap, payer) {
+        return this._vaultClient.disinvestAllReservesIxs(vault, vaultReservesMap, payer);
+    }
     // async closeVault(vault: KaminoVault): Promise<TransactionInstruction> {
     //   return this._vaultClient.closeVaultIx(vault);
     // }
@@ -197,7 +231,7 @@ class KaminoManager {
      * @returns - the reserve config
      */
     async getReserveConfig(reserve) {
-        const reserveState = await lib_1.Reserve.fetch(this._connection, reserve);
+        const reserveState = await lib_1.Reserve.fetch(this._rpc, reserve);
         if (!reserveState) {
             throw new Error('Reserve not found');
         }
@@ -205,14 +239,16 @@ class KaminoManager {
     }
     /**
      * This function enables the update of the scope oracle configuration. In order to get a list of scope prices, getScopeOracleConfigs can be used
+     * @param lendingMarketOwner - market admin
      * @param market - lending market which owns the reserve
      * @param reserve - reserve which to be updated
+     * @param oraclePrices - scope OraclePrices account pubkey
      * @param scopeOracleConfig - new scope oracle config
      * @param scopeTwapConfig - new scope twap config
      * @param maxAgeBufferSeconds - buffer to be added to onchain max_age - if oracle price is older than that, txns interacting with the reserve will fail
      * @returns - an array of instructions used update the oracle configuration
      */
-    async updateReserveScopeOracleConfigurationIxs(market, reserve, scopeOracleConfig, scopeTwapConfig, maxAgeBufferSeconds = 20) {
+    async updateReserveScopeOracleConfigurationIxs(lendingMarketOwner, market, reserve, oraclePrices, scopeOracleConfig, scopeTwapConfig, maxAgeBufferSeconds = 20) {
         const reserveConfig = reserve.state.config;
         let scopeTwapId = scope_sdk_1.U16_MAX;
         if (scopeTwapConfig) {
@@ -222,7 +258,7 @@ class KaminoManager {
             // }
         }
         const { scopeConfiguration } = (0, lib_1.getReserveOracleConfigs)({
-            scopePriceConfigAddress: scopeOracleConfig.scopePriceConfigAddress,
+            scopePriceConfigAddress: oraclePrices,
             scopeChain: [scopeOracleConfig.oracleId],
             scopeTwapChain: [scopeTwapId],
         });
@@ -238,10 +274,11 @@ class KaminoManager {
                 maxAgePriceSeconds: new bn_js_1.default(scopeOracleConfig.max_age + maxAgeBufferSeconds),
             },
         });
-        return this.updateReserveIxs(market, reserve.address, newReserveConfig, reserve.state);
+        return this.updateReserveIxs(lendingMarketOwner, market, reserve.address, newReserveConfig, reserve.state);
     }
     /**
      * This function updates the given reserve with a new config. It can either update the entire reserve config or just update fields which differ between given reserve and existing reserve
+     * @param lendingMarketOwner - market authority
      * @param marketWithAddress - the market that owns the reserve to be updated
      * @param reserve - the reserve to be updated
      * @param config - the new reserve configuration to be used for the update
@@ -249,16 +286,16 @@ class KaminoManager {
      * @param updateEntireConfig - when set to false, it will only update fields that are different between @param config and reserveState.config, set to true it will always update entire reserve config. An entire reserveConfig update might be too large for a multisig transaction
      * @returns - an array of multiple update ixs. If there are many fields that are being updated without the updateEntireConfig=true, multiple transactions might be required to fit all ixs.
      */
-    async updateReserveIxs(marketWithAddress, reserve, config, reserveStateOverride, updateEntireConfig = false) {
+    async updateReserveIxs(lendingMarketOwner, marketWithAddress, reserve, config, reserveStateOverride, updateEntireConfig = false) {
         const reserveState = reserveStateOverride
             ? reserveStateOverride
-            : (await lib_1.Reserve.fetch(this._connection, reserve, this._kaminoLendProgramId));
+            : (await lib_1.Reserve.fetch(this._rpc, reserve, this._kaminoLendProgramId));
         const ixs = [];
         if (!reserveState || updateEntireConfig) {
-            ixs.push((0, lib_1.updateEntireReserveConfigIx)(marketWithAddress.state.lendingMarketOwner, marketWithAddress.address, reserve, config, this._kaminoLendProgramId));
+            ixs.push(await (0, lib_1.updateEntireReserveConfigIx)(lendingMarketOwner, marketWithAddress.address, reserve, config, this._kaminoLendProgramId));
         }
         else {
-            ixs.push(...(0, lib_1.parseForChangesReserveConfigAndGetIxs)(marketWithAddress, reserveState, reserve, config, this._kaminoLendProgramId));
+            ixs.push(...(await (0, lib_1.parseForChangesReserveConfigAndGetIxs)(marketWithAddress, reserveState, reserve, config, this._kaminoLendProgramId, lendingMarketOwner)));
         }
         return ixs;
     }
@@ -304,26 +341,29 @@ class KaminoManager {
      * @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) {
-        return this._vaultClient.setVaultFarmIxs(vault, farm, errorOnOverride);
+    async setVaultFarmIxs(vault, farm, errorOnOverride = true, vaultAdminAuthority) {
+        return this._vaultClient.setVaultFarmIxs(vault, farm, errorOnOverride, vaultAdminAuthority);
     }
     /**
      * 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) {
-        return this._vaultClient.acceptVaultOwnershipIxs(vault);
+    async acceptVaultOwnershipIxs(vault, pendingAdmin) {
+        return this._vaultClient.acceptVaultOwnershipIxs(vault, pendingAdmin);
     }
     /**
      * 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) {
-        return this._vaultClient.giveUpPendingFeesIx(vault, maxAmountToGiveUp);
+    async giveUpPendingFeesIx(vault, maxAmountToGiveUp, vaultAdminAuthority) {
+        return this._vaultClient.giveUpPendingFeesIx(vault, maxAmountToGiveUp, vaultAdminAuthority);
     }
     /**
      * This function will return the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
@@ -342,32 +382,32 @@ class KaminoManager {
      * This method withdraws all the pending fees from the vault to the owner's token ATA
      * @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) {
-        return this._vaultClient.withdrawPendingFeesIxs(vault, slot);
+    async withdrawPendingFeesIxs(vault, slot, vaultAdminAuthority) {
+        return this._vaultClient.withdrawPendingFeesIxs(vault, slot, undefined, vaultAdminAuthority);
     }
     /**
      * This method inserts the missing keys from the provided keys into an existent lookup table
      * @param payer - payer wallet pubkey
-     * @param lookupTable - lookup table to insert the keys into
+     * @param lut - 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
      * @returns - an array of instructions to insert the missing keys into the lookup table
      */
-    async insertIntoLUTIxs(payer, lut, keys, accountsInLUT) {
+    async insertIntoLutIxs(payer, lut, keys, accountsInLUT) {
         return this._vaultClient.insertIntoLookupTableIxs(payer, lut, keys, accountsInLUT);
     }
     /**
      * 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 syncVaultLUTIxs(vault, vaultReserves) {
-        return this._vaultClient.syncVaultLookupTableIxs(vault, vaultReserves);
+    async syncVaultLUTIxs(authority, vault, vaultReserves) {
+        return this._vaultClient.syncVaultLookupTableIxs(authority, vault, vaultReserves);
     }
     /**
      * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
@@ -421,7 +461,7 @@ class KaminoManager {
     }
     /**
      * This method returns the vault name
-     * @param vault - vault to retrieve the onchain name for
+     * @param vaultState - vault to retrieve the onchain name for
      * @returns - the vault name as string
      */
     getDecodedVaultName(vaultState) {
@@ -446,53 +486,51 @@ class KaminoManager {
      */
     async getAllMarkets(programId = programId_1.PROGRAM_ID) {
         // Get all lending markets
-        const marketGenerator = (0, lib_1.getAllLendingMarketAccounts)(this.getConnection(), programId);
+        const marketGenerator = (0, lib_1.getAllLendingMarketAccounts)(this.getRpc(), programId);
         const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
         const lendingMarketPairs = [];
         for await (const pair of marketGenerator) {
             lendingMarketPairs.push(pair);
         }
         // Get all reserves
-        const allReserveAccounts = await (0, lib_1.getAllReserveAccounts)(this.getConnection());
+        const allReserveAccounts = (0, lib_1.getAllReserveAccounts)(this.getRpc());
         const reservePairs = [];
         for await (const pair of allReserveAccounts) {
             reservePairs.push(pair);
         }
         const allReserves = reservePairs.map(([, reserve]) => reserve);
         // Get all oracle accounts
-        const allOracleAccounts = await (0, lib_1.getAllOracleAccounts)(this.getConnection(), allReserves);
-        const switchboardV2 = await sbv2_lite_1.default.loadMainnet(this.getConnection());
+        const allOracleAccounts = await (0, lib_1.getAllOracleAccounts)(this.getRpc(), allReserves);
         // Group reserves by market
-        const marketToReserve = new lib_1.PubkeyHashMap();
-        for (const [reserveAddress, reserveState, buffer] of reservePairs) {
+        const marketToReserve = new Map();
+        for (const [reserveAddress, reserveState] of reservePairs) {
             const marketAddress = reserveState.lendingMarket;
             if (!marketToReserve.has(marketAddress)) {
-                marketToReserve.set(marketAddress, [[reserveAddress, reserveState, buffer]]);
+                marketToReserve.set(marketAddress, [[reserveAddress, reserveState]]);
             }
             else {
-                marketToReserve.get(marketAddress)?.push([reserveAddress, reserveState, buffer]);
+                marketToReserve.get(marketAddress)?.push([reserveAddress, reserveState]);
             }
         }
         const combinedMarkets = lendingMarketPairs.map(([pubkey, market]) => {
             const reserves = marketToReserve.get(pubkey);
-            const reservesByAddress = new lib_1.PubkeyHashMap();
+            const reservesByAddress = new Map();
             if (!reserves) {
                 console.log(`Market ${pubkey.toString()} ${(0, lib_1.parseTokenSymbol)(market.name)} has no reserves`);
             }
             else {
-                const allBuffers = reserves.map(([, , account]) => account);
                 const allReserves = reserves.map(([, reserve]) => reserve);
-                const reservesAndOracles = (0, lib_1.getTokenOracleDataSync)(allOracleAccounts, switchboardV2, allReserves);
+                const reservesAndOracles = (0, lib_1.getTokenOracleDataSync)(allOracleAccounts, allReserves);
                 reservesAndOracles.forEach(([reserve, oracle], index) => {
                     if (!oracle) {
                         console.log('Manager > getAllMarkets: oracle not found for reserve', reserve.config.tokenInfo.name);
                         return;
                     }
-                    const kaminoReserve = lib_1.KaminoReserve.initialize(allBuffers[index], reserves[index][0], reserves[index][1], oracle, this.getConnection(), this.recentSlotDurationMs);
+                    const kaminoReserve = lib_1.KaminoReserve.initialize(reserves[index][0], reserves[index][1], oracle, this.getRpc(), this.recentSlotDurationMs);
                     reservesByAddress.set(kaminoReserve.address, kaminoReserve);
                 });
             }
-            return lib_1.KaminoMarket.loadWithReserves(this.getConnection(), market, reservesByAddress, pubkey, slotDuration);
+            return lib_1.KaminoMarket.loadWithReserves(this.getRpc(), market, reservesByAddress, pubkey, slotDuration);
         });
         return combinedMarkets;
     }
@@ -502,36 +540,33 @@ class KaminoManager {
      * @returns an array of all vaults owned by a given pubkey
      */
     async getAllVaultsForOwner(owner) {
+        const size = accounts_1.VaultState.layout.span + 8;
         const filters = [
             {
-                dataSize: accounts_1.VaultState.layout.span + 8,
+                dataSize: BigInt(size),
             },
             {
                 memcmp: {
-                    offset: 0,
-                    bytes: bs58_1.default.encode(accounts_1.VaultState.discriminator),
+                    offset: 0n,
+                    bytes: base58Decoder.decode(accounts_1.VaultState.discriminator),
+                    encoding: 'base58',
                 },
             },
             {
                 memcmp: {
-                    offset: 8,
-                    bytes: owner.toBase58(),
+                    offset: 8n,
+                    bytes: owner.toString(),
+                    encoding: 'base58',
                 },
             },
         ];
-        const kaminoVaults = await (0, rpc_1.getProgramAccounts)(this._connection, this._kaminoVaultProgramId, accounts_1.VaultState.layout.span + 8, {
-            commitment: this._connection.commitment ?? 'processed',
-            filters,
-        });
+        const kaminoVaults = await (0, rpc_1.getProgramAccounts)(this._rpc, this._kaminoVaultProgramId, size, filters);
         return kaminoVaults.map((kaminoVault) => {
-            if (kaminoVault.account === null) {
-                throw new Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} does not exist`);
-            }
-            const kaminoVaultAccount = (0, vault_2.decodeVaultState)(kaminoVault.account.data);
+            const kaminoVaultAccount = (0, vault_2.decodeVaultState)(kaminoVault.data);
             if (!kaminoVaultAccount) {
-                throw Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} could not be decoded`);
+                throw Error(`kaminoVault with pubkey ${kaminoVault.address} could not be decoded`);
             }
-            return new vault_1.KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
+            return new vault_1.KaminoVault(kaminoVault.address, kaminoVaultAccount, this._kaminoVaultProgramId);
         });
     }
     /**
@@ -551,9 +586,15 @@ class KaminoManager {
         //how to get all token accounts for specific mint: https://spl.solana.com/token#finding-all-token-accounts-for-a-specific-mint
         //get it from the hardcoded token program and create a filter with the actual mint address
         //datasize:165 filter selects all token accounts, memcmp filter selects based on the mint address withing each token account
-        return this._connection.getParsedProgramAccounts(spl_token_1.TOKEN_PROGRAM_ID, {
-            filters: [{ dataSize: 165 }, { memcmp: { offset: 0, bytes: shareMint.toBase58() } }],
-        });
+        return this._rpc
+            .getProgramAccounts(token_1.TOKEN_PROGRAM_ADDRESS, {
+            filters: [
+                { dataSize: 165n },
+                { memcmp: { offset: 0n, bytes: shareMint.toString(), encoding: 'base58' } },
+            ],
+            encoding: 'jsonParsed',
+        })
+            .send();
     }
     /**
      * Get all token accounts that hold shares for a specific vault; if you already have the vault state use it in the param so you don't have to fetch it again
@@ -561,7 +602,7 @@ class KaminoManager {
      * @returns an array of all holders tokenAccounts pubkeys and their account info
      */
     async getVaultTokenAccounts(vault) {
-        const vaultState = await vault.getState(this._connection);
+        const vaultState = await vault.getState(this._rpc);
         return this.getShareTokenAccounts(vaultState.sharesMint);
     }
     /**
@@ -570,13 +611,13 @@ class KaminoManager {
      * @returns an array of all vault holders with their pubkeys and amounts
      */
     getVaultHolders = async (vault) => {
-        await vault.getState(this._connection);
+        await vault.getState(this._rpc);
         const tokenAccounts = await this.getVaultTokenAccounts(vault);
         const result = [];
         for (const tokenAccount of tokenAccounts) {
             const accountData = tokenAccount.account.data;
             result.push({
-                holderPubkey: new web3_js_1.PublicKey(accountData.parsed.info.owner),
+                holderPubkey: (0, kit_1.address)(accountData.parsed.info.owner),
                 amount: new decimal_js_1.default(accountData.parsed.info.tokenAmount.uiAmountString),
             });
         }
@@ -606,7 +647,7 @@ class KaminoManager {
      * @param vault - the kamino vault to get available liquidity to withdraw for
      * @param price - the price of the token in the vault (e.g. USDC)
      * @param [slot] - the slot for which to calculate the holdings. Optional. If not provided the function will fetch the current slot
-     * @param [vaultReservesMap] - 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 [vaultReserves]
      * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
      * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
      */
@@ -618,7 +659,7 @@ class KaminoManager {
      * @param vault - the kamino vault to get available liquidity to withdraw for
      * @param price - the price of the token in the vault (e.g. USDC)
      * @param [slot] - the slot for which to retrieve the vault overview for. Optional. If not provided the function will fetch the current slot
-     * @param [vaultReservesMap] - 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 [vaultReserves] - 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 [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
      * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
      * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD
@@ -659,7 +700,7 @@ class KaminoManager {
      * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves as ratio; for percentage it needs multiplication by 100
      * @param vault - the kamino vault to get APY for
      * @param slot - current slot
-     * @param [vaultReservesMap] - 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 [vaultReserves] - 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 containing estimated gross APY and net APY (gross - vault fees) for the vault
      */
     async getVaultTheoreticalAPY(vault, slot, vaultReserves) {
@@ -716,10 +757,68 @@ class KaminoManager {
         return this._vaultClient.calculateSimulatedFees(vaultState, simulatedCurrentHoldingsWithInterest, currentTimestamp);
     }
     /**
-     * This will compute the PDA that is used as delegatee in Farms program to compute the user state PDA
+     * This will compute the PDA that is used as delegatee in Farms program to compute the user state PDA for vault depositor investing in vault with reserve having a supply farm
+     */
+    computeUserFarmStateForUserInVault(farmsProgramId, vault, reserve, user) {
+        return this._vaultClient.computeUserFarmStateDelegateePDAForUserInVault(farmsProgramId, reserve, vault, user);
+    }
+    /**
+     * Read the APY of the farm built on top of the vault (farm in vaultState.vaultFarm)
+     * @param vault - the vault to read the farm APY for
+     * @param vaultTokenPrice - the price of the vault token in USD (e.g. 1.0 for USDC)
+     * @param [slot] - the slot to read the farm APY for. Optional. If not provided, the function will read the current slot
+     * @returns the APY of the farm built on top of the vault
      */
-    computeUserFarmStateForUserInVault(farmProgramID, vault, reserve, user) {
-        return this._vaultClient.computeUserFarmStateDelegateePDAForUserInVault(farmProgramID, reserve, vault, user);
+    async getVaultFarmRewardsAPY(vault, vaultTokenPrice, slot) {
+        return this._vaultClient.getVaultRewardsAPY(vault, vaultTokenPrice, slot);
+    }
+    /**
+     * This will return the APY of the reserve farms (debt and supply)
+     * @param reserve - the reserve to get the farms APY for
+     * @param reserveTokenPrice - the price of the reserve token in USD (e.g. 1.0 for USDC)
+     * @param [reserveState] - the reserve state. Optional. If not provided, the function will fetch the reserve state
+     * @param [kaminoMarket] - the kamino market. Optional. If not provided, the function will fetch the kamino market
+     * @returns the APY of the farm built on top of the reserve
+     */
+    async getReserveFarmRewardsAPY(reserve, reserveTokenPrice, reserveState, kaminoMarket) {
+        const reserveIncentives = {
+            collateralFarmIncentives: null,
+            debtFarmIncentives: null,
+        };
+        console.log('this._kaminoLendProgramId', this._kaminoLendProgramId.toString());
+        const reserveAccount = reserveState
+            ? reserveState
+            : await lib_1.Reserve.fetch(this._rpc, reserve, this._kaminoLendProgramId);
+        if (!reserveAccount) {
+            throw new Error(`Reserve ${reserve} not found`);
+        }
+        let market = kaminoMarket;
+        if (!market) {
+            const fetckedMarket = await lib_1.KaminoMarket.load(this._rpc, reserveAccount.lendingMarket, 450);
+            if (!fetckedMarket) {
+                throw new Error(`Market ${reserveAccount.lendingMarket} not found`);
+            }
+            market = fetckedMarket;
+        }
+        const kaminoReserve = market.getReserveByAddress(reserve);
+        if (!kaminoReserve) {
+            throw new Error(`Strategy state not found for strategy: ${reserve}`);
+        }
+        const farmCollateral = kaminoReserve.state.farmCollateral;
+        const farmDebt = kaminoReserve.state.farmDebt;
+        const stakedTokenMintDecimals = kaminoReserve.getMintDecimals();
+        const reserveCtokenPrice = reserveTokenPrice.div(kaminoReserve.getCollateralExchangeRate());
+        const farmsClient = new dist_1.Farms(this._rpc);
+        if (farmCollateral !== lib_1.DEFAULT_PUBLIC_KEY) {
+            const farmIncentivesCollateral = await (0, apy_1.getFarmIncentives)(farmsClient, farmCollateral, reserveCtokenPrice, 6 // all cTokens have 6 decimals
+            );
+            reserveIncentives.collateralFarmIncentives = farmIncentivesCollateral;
+        }
+        if (farmDebt !== lib_1.DEFAULT_PUBLIC_KEY) {
+            const farmIncentivesDebt = await (0, apy_1.getFarmIncentives)(farmsClient, farmDebt, reserveTokenPrice, stakedTokenMintDecimals);
+            reserveIncentives.debtFarmIncentives = farmIncentivesDebt;
+        }
+        return reserveIncentives;
     }
     /**
      * This will load the onchain state for all the reserves that the vault has allocations for
@@ -756,6 +855,7 @@ class KaminoManager {
     }
     /**
      * This will trigger invest by balancing, based on weights, the reserve allocations of the vault. It can either withdraw or deposit into reserves to balance them. This is a function that should be cranked
+     * @param payer
      * @param kaminoVault - vault to invest from
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
@@ -764,9 +864,9 @@ class KaminoManager {
     }
     /**
      * 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
-     * @param vault - vault to invest from
-     * @param reserve - reserve to invest into or disinvest from
+     * @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 kaminoVault - vault to invest from
+     * @param reserveWithAddress - 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
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
@@ -801,66 +901,78 @@ class KaminoManager {
     }
     /**
      * This returns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
-     * @param feed - scope feed to fetch prices from
+     * @param market kamino market
      * @param cluster - cluster to fetch from, this should be left unchanged unless working on devnet or locally
-     * @returns - an array of scope oracle configs
-     */
-    async getScopeOracleConfigs(feed = 'hubble', cluster = 'mainnet-beta') {
-        const scopeOracleConfigs = [];
-        const scope = new scope_sdk_1.Scope(cluster, this._connection);
-        const oracleMappings = await scope.getOracleMappings({ feed: feed });
-        const [, feedConfig] = await scope.getFeedConfiguration({ feed: feed });
-        const tokenMetadatas = await scope_sdk_1.TokenMetadatas.fetch(this._connection, feedConfig.tokensMetadata);
-        const decoder = new TextDecoder('utf-8');
-        console.log('feedConfig.tokensMetadata', feedConfig.tokensMetadata);
-        if (tokenMetadatas === null) {
-            throw new Error('TokenMetadatas not found');
+     * @returns - a map with keys as scope OraclePrices pubkeys and values of scope oracle configs
+     */
+    async getScopeOracleConfigs(market, cluster = 'mainnet-beta') {
+        const scopeOracleConfigs = new Map();
+        const scope = new scope_sdk_1.Scope(cluster, this._rpc);
+        const configs = (await scope.getAllConfigurations()).filter(([_, config]) => market.scopeFeeds.has(config.oraclePrices));
+        if (!configs || configs.length === 0) {
+            return scopeOracleConfigs;
         }
-        for (let index = 0; index < oracleMappings.priceInfoAccounts.length; index++) {
-            if (!oracleMappings.priceInfoAccounts[index].equals(web3_js_1.PublicKey.default)) {
-                const name = decoder.decode(Uint8Array.from(tokenMetadatas.metadatasArray[index].name)).replace(/\0/g, '');
-                const oracleType = (0, lib_1.parseOracleType)(oracleMappings.priceTypes[index]);
-                scopeOracleConfigs.push({
-                    scopePriceConfigAddress: feedConfig.oraclePrices,
-                    name: name,
-                    oracleType: oracleType,
-                    oracleId: index,
-                    oracleAccount: oracleMappings.priceInfoAccounts[index],
-                    twapEnabled: oracleMappings.twapEnabled[index] === 1,
-                    twapSourceId: oracleMappings.twapSource[index],
-                    max_age: tokenMetadatas.metadatasArray[index].maxAgePriceSlots.toNumber(),
-                });
+        const configOracleMappings = await accounts_2.OracleMappings.fetchMultiple(this._rpc, configs.map(([_, config]) => config.oracleMappings), scope.config.programId);
+        const configTokenMetadatas = await TokenMetadatas_1.TokenMetadatas.fetchMultiple(this._rpc, configs.map(([_, config]) => config.tokensMetadata), scope.config.programId);
+        const decoder = new TextDecoder('utf-8');
+        for (let i = 0; i < configs.length; i++) {
+            const [configPubkey, config] = configs[i];
+            const oracleMappings = configOracleMappings[i];
+            const tokenMetadatas = configTokenMetadatas[i];
+            if (!oracleMappings) {
+                throw new Error(`OracleMappings account not found for config ${configPubkey}`);
+            }
+            if (!tokenMetadatas) {
+                throw new Error(`TokenMetadatas account not found for config ${configPubkey}`);
+            }
+            for (let j = 0; j < oracleMappings.priceInfoAccounts.length; j++) {
+                if (oracleMappings.priceInfoAccounts[j] !== lib_1.DEFAULT_PUBLIC_KEY) {
+                    const name = decoder.decode(Uint8Array.from(tokenMetadatas.metadatasArray[j].name)).replace(/\0/g, '');
+                    const oracleType = (0, lib_1.parseOracleType)(oracleMappings.priceTypes[j]);
+                    (0, lib_1.setOrAppend)(scopeOracleConfigs, config.oraclePrices, {
+                        name: name,
+                        oracleType: oracleType,
+                        oracleId: j,
+                        oracleAccount: oracleMappings.priceInfoAccounts[j],
+                        twapEnabled: oracleMappings.twapEnabled[j] === 1,
+                        twapSourceId: oracleMappings.twapSource[j],
+                        max_age: tokenMetadatas.metadatasArray[j].maxAgePriceSlots.toNumber(),
+                    });
+                }
             }
         }
         return scopeOracleConfigs;
     }
     /**
      * This retruns an array of instructions to be used to update the lending market configurations
+     * @param lendingMarketOwner - market admin
      * @param marketWithAddress - the market address and market state object
      * @param newMarket - the lending market state with the new configuration - to be build we new config options from the previous state
      * @returns - an array of instructions
      */
-    updateLendingMarketIxs(marketWithAddress, newMarket) {
-        return parseForChangesMarketConfigAndGetIxs(marketWithAddress, newMarket, this._kaminoLendProgramId);
+    updateLendingMarketIxs(lendingMarketOwner, marketWithAddress, newMarket) {
+        return parseForChangesMarketConfigAndGetIxs(lendingMarketOwner, marketWithAddress, newMarket, this._kaminoLendProgramId);
     }
     /**
      * This retruns an array of instructions to be used to update the pending lending market admin; if the admin is the same the list will be empty otherwise it will have an instruction to update the cached (pending) admin
+     * @param currentAdmin - current lending market owner
      * @param marketWithAddress - the market address and market state object
      * @param newAdmin - the new admin
      * @returns - an array of instructions
      */
-    updatePendingLendingMarketAdminIx(marketWithAddress, newAdmin) {
+    updatePendingLendingMarketAdminIx(currentAdmin, marketWithAddress, newAdmin) {
         const newMarket = new lib_1.LendingMarket({ ...marketWithAddress.state, lendingMarketOwnerCached: newAdmin });
-        return this.updateLendingMarketIxs(marketWithAddress, newMarket);
+        return this.updateLendingMarketIxs(currentAdmin, marketWithAddress, newMarket);
     }
     /**
-     * This retruns an instruction to be used to update the market owner. This can only be executed by the current lendingMarketOwnerCached
+     * This returns an instruction to be used to update the market owner. This can only be executed by the current lendingMarketOwnerCached
      * @param marketWithAddress - the market address and market state object
+     * @param lendingMarketOwnerCached - lendingMarketOwnerCached signer - a noop signer suitable for multisigs is used if not provided
      * @returns - an instruction for the new owner
      */
-    updateLendingMarketOwnerIxs(marketWithAddress) {
+    updateLendingMarketOwnerIxs(marketWithAddress, lendingMarketOwnerCached = (0, signer_1.noopSigner)(marketWithAddress.state.lendingMarketOwnerCached)) {
         const accounts = {
-            lendingMarketOwnerCached: marketWithAddress.state.lendingMarketOwnerCached,
+            lendingMarketOwnerCached,
             lendingMarket: marketWithAddress.address,
         };
         return (0, lib_1.updateLendingMarketOwner)(accounts, this._kaminoLendProgramId);
@@ -875,26 +987,26 @@ class KaminoManager {
     }
     /**
      * This will get the wallet type, admins number and threshold for the given authority
-     * @param connection - the connection to use
+     * @param rpc - the rpc to use
      * @param address - the address to get the wallet info for
      * @returns the wallet type, admins number and threshold
      */
-    static async getMarketOrVaultAdminInfo(connection, address) {
+    static async getMarketOrVaultAdminInfo(rpc, address) {
         try {
             // Try to fetch vault state first
-            const vaultState = await accounts_1.VaultState.fetch(connection, address);
+            const vaultState = await accounts_1.VaultState.fetch(rpc, address);
             if (!vaultState) {
                 throw new Error('Vault not found');
             }
-            return await KaminoManager.getWalletInfo(connection, vaultState.vaultAdminAuthority);
+            return await KaminoManager.getWalletInfo(rpc, vaultState.vaultAdminAuthority);
         }
         catch (error) {
             // If vault not found, try to fetch market state
-            const market = await lib_1.LendingMarket.fetch(connection, address);
+            const market = await lib_1.LendingMarket.fetch(rpc, address);
             if (!market) {
                 return undefined;
             }
-            return await KaminoManager.getWalletInfo(connection, market.lendingMarketOwner);
+            return await KaminoManager.getWalletInfo(rpc, market.lendingMarketOwner);
         }
     }
     /**
@@ -944,17 +1056,17 @@ exports.MARKET_UPDATER = new configItems_1.ConfigUpdater(types_1.UpdateLendingMa
     [types_1.UpdateLendingMarketMode.UpdateObligationOrderCreationEnabled.kind]: config.obligationOrderCreationEnabled,
     [types_1.UpdateLendingMarketMode.UpdateObligationOrderExecutionEnabled.kind]: config.obligationOrderExecutionEnabled,
 }));
-function parseForChangesMarketConfigAndGetIxs(marketWithAddress, newMarket, programId) {
+function parseForChangesMarketConfigAndGetIxs(lendingMarketOwner, marketWithAddress, newMarket, programId) {
     const encodedMarketUpdates = exports.MARKET_UPDATER.encodeAllUpdates(marketWithAddress.state, newMarket);
-    return encodedMarketUpdates.map((encodedMarketUpdate) => updateMarketConfigIx(marketWithAddress, encodedMarketUpdate.mode, encodedMarketUpdate.value, programId));
+    return encodedMarketUpdates.map((encodedMarketUpdate) => updateMarketConfigIx(lendingMarketOwner, marketWithAddress, encodedMarketUpdate.mode, encodedMarketUpdate.value, programId));
 }
-function updateMarketConfigIx(marketWithAddress, mode, value, programId) {
+function updateMarketConfigIx(lendingMarketOwner, marketWithAddress, mode, value, programId) {
     const accounts = {
-        lendingMarketOwner: marketWithAddress.state.lendingMarketOwner,
+        lendingMarketOwner,
         lendingMarket: marketWithAddress.address,
     };
     const args = {
-        mode: new anchor.BN(mode.discriminator),
+        mode: new bn_js_1.default(mode.discriminator),
         // NOTE: the Market's update handler expects a `[u8; 72]` (contrary to e.g. the Reserve's update handler accepting
         // `Vec<u8>`). Hence, we need to add explicit padding here:
         value: [...value, ...Array(72 - value.length).fill(0)],