@kamino-finance/klend-sdk 6.0.3 → 6.0.5-beta.0

package/dist/client_kamino_manager.js

@@ -0,0 +1,1202 @@
+"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.parseKeypairFile = parseKeypairFile;
+const dotenv_1 = __importDefault(require("dotenv"));
+const commander_1 = require("commander");
+const web3_js_1 = require("@solana/web3.js");
+const lib_1 = require("./lib");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const base58_js_1 = require("base58-js");
+const types_1 = require("./idl_codegen/types");
+const fraction_1 = require("./classes/fraction");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const anchor_1 = require("@coral-xyz/anchor");
+const types_2 = require("./idl_codegen_kamino_vault/types");
+const fs = __importStar(require("fs"));
+const VaultConfigField_1 = require("./idl_codegen_kamino_vault/types/VaultConfigField");
+const rpc_1 = require("./utils/rpc");
+const spl_token_1 = require("@solana/spl-token");
+dotenv_1.default.config({
+    path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
+});
+async function main() {
+    const commands = new commander_1.Command();
+    commands.name('kamino-manager-cli').description('CLI to interact with the kvaults and klend programs');
+    commands
+        .command('create-market')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig pubkey is required');
+        }
+        const multisigPk = multisig ? new web3_js_1.PublicKey(multisig) : web3_js_1.PublicKey.default;
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const { market: marketKp, ixs: createMarketIxs } = await kaminoManager.createMarketIxs({
+            admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
+        });
+        await processTxn(env.client, env.payer, createMarketIxs, mode, 2500, [marketKp]);
+        mode === 'execute' && console.log('Market created:', marketKp.publicKey.toBase58());
+    });
+    commands
+        .command('add-asset-to-market')
+        .requiredOption('--market <string>', 'Market address to add asset to')
+        .requiredOption('--mint <string>', 'Reserve liquidity token mint')
+        .requiredOption('--mint-program-id <string>', 'Reserve liquidity token mint program id')
+        .requiredOption('--reserve-config-path <string>', 'Path for the reserve config')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ market, mint, mintProgramId, reserveConfigPath, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const tokenMint = new web3_js_1.PublicKey(mint);
+        const tokenMintProgramId = new web3_js_1.PublicKey(mintProgramId);
+        const marketAddress = new web3_js_1.PublicKey(market);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const multisigPk = multisig ? new web3_js_1.PublicKey(multisig) : web3_js_1.PublicKey.default;
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const reserveConfigFromFile = JSON.parse(fs.readFileSync(reserveConfigPath, 'utf8'));
+        const reserveConfig = parseReserveConfigFromFile(reserveConfigFromFile);
+        const assetConfig = new lib_1.AssetReserveConfigCli(tokenMint, tokenMintProgramId, reserveConfig);
+        const adminAta = mode === 'multisig'
+            ? (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, multisigPk)
+            : (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, env.payer.publicKey);
+        const { reserve, txnIxs } = await kaminoManager.addAssetToMarketIxs({
+            admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
+            adminLiquiditySource: adminAta,
+            marketAddress: marketAddress,
+            assetConfig: assetConfig,
+        });
+        console.log('reserve: ', reserve.publicKey);
+        const _createReserveSig = await processTxn(env.client, env.payer, txnIxs[0], mode, 2500, [reserve]);
+        const [lut, createLutIxs] = await createUpdateReserveConfigLutIxs(env, marketAddress, reserve.publicKey);
+        await processTxn(env.client, env.payer, createLutIxs, mode, 2500, []);
+        const _updateSig = await processTxn(env.client, env.payer, txnIxs[1], mode, 2500, [], 400_000, 1000, [lut]);
+        mode === 'execute' &&
+            console.log('Reserve Created with config:', JSON.parse(JSON.stringify(reserveConfig)), '\nreserve address:', reserve.publicKey.toBase58());
+    });
+    commands
+        .command('update-reserve-config')
+        .requiredOption('--reserve <string>', 'Reserve address')
+        .requiredOption('--reserve-config-path <string>', 'Path for the reserve config')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option('--update-entire-config', 'If set, it will update entire reserve config in 1 instruction')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ reserve, reserveConfigPath, mode, updateEntireConfig, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const reserveAddress = new web3_js_1.PublicKey(reserve);
+        const reserveState = await lib_1.Reserve.fetch(env.connection, reserveAddress, env.kLendProgramId);
+        if (!reserveState) {
+            throw new Error('Reserve not found');
+        }
+        const marketAddress = reserveState.lendingMarket;
+        const marketState = await lib_1.LendingMarket.fetch(env.connection, marketAddress, env.kLendProgramId);
+        if (!marketState) {
+            throw new Error('Market not found');
+        }
+        const marketWithAddress = {
+            address: marketAddress,
+            state: marketState,
+        };
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const reserveConfigFromFile = JSON.parse(fs.readFileSync(reserveConfigPath, 'utf8'));
+        const reserveConfig = parseReserveConfigFromFile(reserveConfigFromFile);
+        const ixs = await kaminoManager.updateReserveIxs(marketWithAddress, reserveAddress, reserveConfig, reserveState, updateEntireConfig);
+        const _updateReserveSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+        mode === 'execute' && console.log('Reserve Updated with config -> ', JSON.parse(JSON.stringify(reserveConfig)));
+    });
+    commands
+        .command('download-reserve-config')
+        .requiredOption('--reserve <string>', 'Reserve address')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ reserve, staging }) => {
+        const env = initializeClient(false, staging);
+        const reserveAddress = new web3_js_1.PublicKey(reserve);
+        const reserveState = await lib_1.Reserve.fetch(env.connection, reserveAddress, env.kLendProgramId);
+        if (!reserveState) {
+            throw new Error('Reserve not found');
+        }
+        fs.mkdirSync('./configs/' + reserveState.lendingMarket.toBase58(), { recursive: true });
+        const decoder = new TextDecoder('utf-8');
+        const reserveName = decoder.decode(Uint8Array.from(reserveState.config.tokenInfo.name)).replace(/\0/g, '');
+        const reserveConfigDisplay = parseReserveConfigToFile(reserveState.config);
+        fs.writeFileSync('./configs/' + reserveState.lendingMarket.toBase58() + '/' + reserveName + '.json', JSON.stringify(reserveConfigDisplay, null, 2));
+    });
+    commands
+        .command('create-vault')
+        .requiredOption('--mint <string>', 'Vault token mint')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .requiredOption('--name <string>', 'The onchain name of the strat')
+        .requiredOption('--tokenName <string>', 'The name of the token in the vault')
+        .requiredOption('--extraTokenName <string>', 'The extra string appended to the token symbol')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ mint, mode, name, tokenName, extraTokenName, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const tokenMint = new web3_js_1.PublicKey(mint);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const multisigPk = multisig ? new web3_js_1.PublicKey(multisig) : web3_js_1.PublicKey.default;
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const tokenProgramID = await (0, rpc_1.getAccountOwner)(env.connection, tokenMint);
+        const kaminoVaultConfig = new lib_1.KaminoVaultConfig({
+            admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
+            tokenMint: tokenMint,
+            tokenMintProgramId: tokenProgramID,
+            performanceFeeRatePercentage: new decimal_js_1.default(0.0),
+            managementFeeRatePercentage: new decimal_js_1.default(0.0),
+            name,
+            vaultTokenSymbol: tokenName,
+            vaultTokenName: extraTokenName,
+        });
+        const { vault: vaultKp, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
+        const _createVaultSig = await processTxn(env.client, env.payer, [...instructions.createAtaIfNeededIxs, ...instructions.initVaultIxs, instructions.createLUTIx], mode, 2500, [vaultKp]);
+        await (0, lib_1.sleep)(2000);
+        const _populateLUTSig = await processTxn(env.client, env.payer, [...instructions.populateLUTIxs, ...instructions.cleanupIxs], mode, 2500, []);
+        const _setSharesMetadataSig = await processTxn(env.client, env.payer, [instructions.initSharesMetadataIx], mode, 2500, []);
+        mode === 'execute' && console.log('Vault created:', vaultKp.publicKey.toBase58());
+    });
+    commands
+        .command('set-shares-metadata')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--symbol <string>', 'The symbol of the kVault token')
+        .requiredOption('--extraName <string>', 'The name of the kVault token, appended to the symbol')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .action(async ({ vault, symbol, extraName, mode }) => {
+        const env = initializeClient(false, false);
+        const kVault = new lib_1.KaminoVault(new web3_js_1.PublicKey(vault));
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const ix = await kaminoManager.getSetSharesMetadataIx(kVault, symbol, extraName);
+        await processTxn(env.client, env.payer, [ix], mode, 2500, []);
+    });
+    commands
+        .command('update-vault-pending-admin')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--new-admin <string>', 'Pubkey of the new admin')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, newAdmin, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new VaultConfigField_1.PendingVaultAdmin(), newAdmin);
+        const updateVaultPendingAdminSig = await processTxn(env.client, env.payer, [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs], mode, 2500, []);
+        mode === 'execute' && console.log('Pending admin updated:', updateVaultPendingAdminSig);
+    });
+    commands
+        .command('update-vault-config')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--field <string>', 'The field to update')
+        .requiredOption('--value <string>', 'The value to update the field to')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, field, value, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, field, value);
+        const updateVaultPendingAdminSig = await processTxn(env.client, env.payer, [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs], mode, 2500, []);
+        mode === 'execute' && console.log('Vault updated:', updateVaultPendingAdminSig);
+    });
+    commands
+        .command('update-vault-mgmt-fee')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--fee-bps <string>', 'Pubkey of the new admin')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, feeBps, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new VaultConfigField_1.ManagementFeeBps(), feeBps);
+        const updateVaultConfigSig = await processTxn(env.client, env.payer, [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs], mode, 2500, []);
+        mode === 'execute' && console.log('Management fee updated:', updateVaultConfigSig);
+    });
+    commands
+        .command('insert-into-lut')
+        .requiredOption('--lut <string>', 'Lookup table address')
+        .requiredOption('--addresses <string>', 'The addresses to insert into the LUT, space separated')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ lut, addresses, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const lutAddress = new web3_js_1.PublicKey(lut);
+        const addressesArr = addresses.split(' ').map((address) => new web3_js_1.PublicKey(address));
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const instructions = await kaminoManager.insertIntoLUTIxs(env.payer.publicKey, lutAddress, addressesArr);
+        const updateVaultConfigSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+        mode === 'execute' && console.log('Management fee updated:', updateVaultConfigSig);
+    });
+    commands.command('create-lut').action(async () => {
+        const env = initializeClient(false, false);
+        const initLutIx = (0, lib_1.initLookupTableIx)(env.payer.publicKey, await env.connection.getSlot());
+        const updateVaultConfigSig = await processTxn(env.client, env.payer, [initLutIx[0]], 'execute', 2500, []);
+        console.log(`LUT created: ${initLutIx[1].toString()} tx id: ${updateVaultConfigSig}`);
+    });
+    commands
+        .command('sync-vault-lut')
+        .requiredOption('--vault <string>', 'The vault address to sync')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const syncLUTIxs = await kaminoManager.syncVaultLUTIxs(kaminoVault);
+        // if we need to create the LUT we have to do that in a separate tx and wait a little bit after
+        if (syncLUTIxs.setupLUTIfNeededIxs.length > 0) {
+            const setupLUTSig = await processTxn(env.client, env.payer, syncLUTIxs.setupLUTIfNeededIxs, mode, 2500, []);
+            await (0, lib_1.sleep)(2000);
+            mode === 'execute' && console.log('LUT created and set to the vault:', setupLUTSig);
+        }
+        // if there are accounts to be added to the LUT we have to do that in a separate tx
+        for (const ix of syncLUTIxs.syncLUTIxs) {
+            const insertIntoLUTSig = await processTxn(env.client, env.payer, [ix], mode, 2500, []);
+            mode === 'execute' && console.log('Accounts added to the LUT:', insertIntoLUTSig);
+        }
+    });
+    commands
+        .command('update-vault-perf-fee')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--fee-bps <string>', 'Pubkey of the new admin')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, feeBps, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new VaultConfigField_1.PerformanceFeeBps(), feeBps);
+        const updateVaultPerfFeeSig = await processTxn(env.client, env.payer, [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs], mode, 2500, []);
+        mode === 'execute' && console.log('Performance fee updated:', updateVaultPerfFeeSig);
+    });
+    commands
+        .command('accept-vault-ownership')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.acceptVaultOwnershipIxs(kaminoVault);
+        const acceptVaultOwnershipSig = await processTxn(env.client, env.payer, [instructions.acceptVaultOwnershipIx], mode, 2500, []);
+        mode === 'execute' && console.log('Vault ownership accepted:', acceptVaultOwnershipSig);
+        await processTxn(env.client, env.payer, [instructions.initNewLUTIx], mode, 2500, []);
+        // send the LUT mgmt ixs one by one
+        const lutIxs = [...instructions.updateLUTIxs];
+        for (let i = 0; i < lutIxs.length; i++) {
+            const lutIxsGroup = lutIxs.slice(i, i + 1);
+            const lutIxsSig = await processTxn(env.client, env.payer, lutIxsGroup, mode, 2500, []);
+            mode === 'execute' && console.log('LUT updated:', lutIxsSig);
+        }
+    });
+    commands
+        .command('give-up-pending-fees')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--max-amount-to-give-up <string>', 'Max amount to give up')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, maxAmountToGiveUp, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instruction = await kaminoManager.giveUpPendingFeesIx(kaminoVault, new decimal_js_1.default(maxAmountToGiveUp));
+        const giveUpPendingFeesSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+        mode === 'execute' && console.log('Give up pending fees tx:', giveUpPendingFeesSig);
+    });
+    commands
+        .command('withdraw-pending-fees')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.withdrawPendingFeesIxs(kaminoVault, await env.connection.getSlot('confirmed'));
+        const withdrawPendingFeesSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+        mode === 'execute' && console.log('Pending fees withdrawn:', withdrawPendingFeesSig);
+    });
+    commands
+        .command('remove-vault-allocation')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--reserve <string>', 'Reserve address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, reserve, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const reserveAddress = new web3_js_1.PublicKey(reserve);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instruction = await kaminoManager.removeReserveFromAllocationIx(kaminoVault, reserveAddress);
+        if (instruction) {
+            const updateVaultAllocationSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+            mode === 'execute' && console.log('Vault allocation updated:', updateVaultAllocationSig);
+        }
+    });
+    commands
+        .command('stake')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const stakeIxs = await new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId).stakeSharesIxs(env.payer.publicKey, kaminoVault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const withdrawPendingFeesSig = await processTxn(env.client, env.payer, stakeIxs, mode, 2500, []);
+        mode === 'execute' && console.log('Stake into vault farm:', withdrawPendingFeesSig);
+    });
+    commands
+        .command('update-vault-reserve-allocation')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--reserve <string>', 'Reserve address')
+        .requiredOption('--allocation-weight <number>', 'Allocation weight')
+        .requiredOption('--allocation-cap <string>', 'Allocation cap decimal value')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, reserve, allocationWeight, allocationCap, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const reserveAddress = new web3_js_1.PublicKey(reserve);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const allocationWeightValue = Number(allocationWeight);
+        const allocationCapDecimal = new decimal_js_1.default(allocationCap);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const reserveState = await lib_1.Reserve.fetch(env.connection, reserveAddress, env.kLendProgramId);
+        if (!reserveState) {
+            throw new Error('Reserve not found');
+        }
+        const reserveWithAddress = {
+            address: reserveAddress,
+            state: reserveState,
+        };
+        const firstReserveAllocationConfig = new lib_1.ReserveAllocationConfig(reserveWithAddress, allocationWeightValue, allocationCapDecimal);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.updateVaultReserveAllocationIxs(kaminoVault, firstReserveAllocationConfig);
+        const updateVaultAllocationSig = await processTxn(env.client, env.payer, [instructions.updateReserveAllocationIx, ...instructions.updateLUTIxs], mode, 2500, []);
+        mode === 'execute' && console.log('Vault allocation updated:', updateVaultAllocationSig);
+    });
+    commands
+        .command('deposit')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--amount <number>', 'Token amount to deposit, in decimals')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, amount, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const depositInstructions = await kaminoManager.depositToVaultIxs(env.payer.publicKey, kaminoVault, amount);
+        const instructions = [...depositInstructions.depositIxs, ...depositInstructions.stakeInFarmIfNeededIxs];
+        const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
+        mode === 'execute' && console.log('User deposit:', depositSig);
+    });
+    commands
+        .command('withdraw')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--amount <number>', 'Shares amount to withdraw')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, amount, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const withdrawIxs = await kaminoManager.withdrawFromVaultIxs(env.payer.publicKey, kaminoVault, new decimal_js_1.default(amount), await env.connection.getSlot('confirmed'));
+        const withdrawSig = await processTxn(env.client, env.payer, [...withdrawIxs.unstakeFromFarmIfNeededIxs, ...withdrawIxs.withdrawIxs, ...withdrawIxs.postWithdrawIxs], mode, 2500, [], 800_000);
+        mode === 'execute' && console.log('User withdraw:', withdrawSig);
+    });
+    commands
+        .command('invest-all-reserves')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const instructions = await kaminoManager.investAllReservesIxs(env.payer.publicKey, kaminoVault);
+        for (let i = 0; i < instructions.length; i++) {
+            const txInstructions = [];
+            txInstructions.push(instructions[i]);
+            const investReserveSig = await processTxn(env.client, env.payer, txInstructions, mode, 2500, [], 800000);
+            mode === 'execute' && console.log('Reserve invested:', investReserveSig);
+        }
+    });
+    commands
+        .command('invest-single-reserve')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--reserve <string>', 'Reserve address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+        .action(async ({ vault, reserve, mode, staging, multisig }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        if (mode === 'multisig' && !multisig) {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const reserveState = await lib_1.Reserve.fetch(env.connection, new web3_js_1.PublicKey(reserve), env.kLendProgramId);
+        if (!reserveState) {
+            throw new Error('Reserve not found');
+        }
+        const reserveWithAddress = {
+            address: new web3_js_1.PublicKey(reserve),
+            state: reserveState,
+        };
+        const instructions = await kaminoManager.investSingleReserveIxs(env.payer.publicKey, kaminoVault, reserveWithAddress);
+        const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
+        mode === 'execute' && console.log('Reserve invested:', investReserveSig);
+    });
+    // commands
+    //   .command('close-vault')
+    //   .requiredOption('--vault <string>', 'Vault address')
+    //   .option(`--staging`, 'If true, will use the staging programs')
+    //   .action(async ({vault, staging}) => {
+    //     const env = initializeClient(false, staging);
+    //     const vaultAddress = new PublicKey(vault);
+    //     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+    //     const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+    //     const instructions = await kaminoManager.closeVault(kaminoVault);
+    //     const closeVaultSig = await processTxn(env.client, env.payer, [instructions], 'execute', 2500, []);
+    //     console.log('Vault closed:', closeVaultSig);
+    //   });
+    commands
+        .command('get-vault-colls')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const vaultState = await new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+        const vaultCollaterals = await kaminoManager.getVaultCollaterals(vaultState, await env.connection.getSlot('confirmed'));
+        vaultCollaterals.forEach((collateral) => {
+            console.log('reserve ', collateral.address);
+            console.log('market overview', collateral.reservesAsCollateral);
+            console.log('min LTV', collateral.minLTVPct);
+            console.log('max LTV', collateral.maxLTVPct);
+        });
+    });
+    commands
+        .command('get-vault-overview')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const vaultState = await new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+        const vaultOverview = await kaminoManager.getVaultOverview(vaultState, new decimal_js_1.default(1.0), await env.connection.getSlot('confirmed'));
+        console.log('vaultOverview', vaultOverview);
+    });
+    commands
+        .command('get-vault-allocation-distribution')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const vaultState = await new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+        const allocationDistribution = kaminoManager.getAllocationsDistribuionPct(vaultState);
+        allocationDistribution.forEach((allocation, reserveAddress) => {
+            console.log('reserve ', reserveAddress);
+            console.log('allocation', allocation);
+        });
+    });
+    commands
+        .command('get-user-shares-for-vault')
+        .requiredOption('--vault <string>', 'Vault address')
+        .requiredOption('--wallet <string>', 'User wailt address')
+        .action(async ({ vault, wallet }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const walletAddress = new web3_js_1.PublicKey(wallet);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const userShares = await kaminoManager.getUserSharesBalanceSingleVault(walletAddress, kaminoVault);
+        console.log(`User shares for vault ${vaultAddress.toBase58()}: unstaked shares: ${userShares.unstakedShares} staked shares: ${userShares.stakedShares} total shares: ${userShares.totalShares}`);
+    });
+    commands
+        .command('get-user-shares-all-vaults')
+        .requiredOption('--wallet <string>', 'User wailt address')
+        .action(async ({ wallet }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const walletAddress = new web3_js_1.PublicKey(wallet);
+        const userShares = await kaminoManager.getUserSharesBalanceAllVaults(walletAddress);
+        userShares.forEach((userShares, vaultAddress) => {
+            console.log(`User shares for vault ${vaultAddress}: staked shares ${userShares.stakedShares} unstaked shares ${userShares.unstakedShares} total shares ${userShares.totalShares}`);
+        });
+    });
+    commands
+        .command('get-tokens-per-share')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        const tokensPerShare = await kaminoManager.getTokensPerShareSingleVault(kaminoVault, await env.connection.getSlot('confirmed'));
+        console.log(`Tokens per share for vault ${vaultAddress.toBase58()}: ${tokensPerShare}`);
+    });
+    commands
+        .command('print-vault')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const kaminoVault = new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+        await kaminoVault.getState(env.connection);
+        const slot = await env.connection.getSlot('confirmed');
+        const tokensPerShare = await kaminoManager.getTokensPerShareSingleVault(kaminoVault, slot);
+        const holdings = await kaminoManager.getVaultHoldings(kaminoVault.state, slot);
+        const vaultState = kaminoVault.state;
+        const sharesIssued = (0, lib_1.lamportsToDecimal)(vaultState.sharesIssued.toString(), vaultState.sharesMintDecimals.toString());
+        const vaultOverview = await kaminoManager.getVaultOverview(vaultState, new decimal_js_1.default(1.0), slot);
+        console.log('farm', vaultState.vaultFarm.toString());
+        console.log('vault token mint', vaultState.tokenMint.toBase58());
+        console.log('Name: ', kaminoManager.getDecodedVaultName(kaminoVault.state));
+        console.log('Shares issued: ', sharesIssued);
+        (0, lib_1.printHoldings)(holdings);
+        console.log(`Tokens per share for vault ${vaultAddress.toBase58()}: ${tokensPerShare}`);
+        console.log('vaultOverview', vaultOverview);
+        for (const [reserveAddress, reserveOverview] of vaultOverview.reservesOverview) {
+            console.log(`reserve ${reserveAddress.toBase58()} supplyAPY ${reserveOverview.supplyAPY}`);
+        }
+    });
+    commands.command('get-oracle-mappings').action(async () => {
+        const env = initializeClient(false, false);
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        console.log('Getting  oracle mappings');
+        const oracleConfigs = await kaminoManager.getScopeOracleConfigs();
+        console.log('oracleConfigs', JSON.parse(JSON.stringify(oracleConfigs)));
+    });
+    commands.command('get-all-vaults').action(async () => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const allVaults = await kaminoManager.getAllVaults();
+        console.log('all vaults', allVaults);
+    });
+    commands
+        .command('get-all-vaults-for-token')
+        .requiredOption('--token <string>', 'Token address')
+        .action(async ({ token }) => {
+        const env = initializeClient(false, false);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const allVaults = await kaminoManager.getAllVaultsForToken(new web3_js_1.PublicKey(token));
+        console.log('all vaults for token ', token, allVaults);
+    });
+    commands.command('get-all-vaults-pks').action(async () => {
+        const env = initializeClient(false, false);
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const allVaults = await kaminoManager.getAllVaults();
+        console.log('all vaults', allVaults.map((vault) => vault.address.toBase58()));
+    });
+    commands
+        .command('get-simulated-interest-and-fees')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultState = await new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+        const simulatedHoldings = await kaminoManager.calculateSimulatedHoldingsWithInterest(vaultState);
+        console.log('Simulated holdings with interest', simulatedHoldings);
+        const simulatedFees = await kaminoManager.calculateSimulatedFees(vaultState, simulatedHoldings);
+        console.log('Simulated fees', simulatedFees);
+    });
+    commands
+        .command('download-lending-market-config')
+        .requiredOption('--lending-market <string>', 'Lending Market Address')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ lendingMarket, staging }) => {
+        const env = initializeClient(false, staging);
+        const lendingMarketAddress = new web3_js_1.PublicKey(lendingMarket);
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        fs.mkdirSync('./configs/' + lendingMarketAddress.toBase58(), { recursive: true });
+        const lendingMarketConfigForFile = lendingMarketState.toJSON();
+        fs.writeFileSync('./configs/' + lendingMarketAddress.toBase58() + '/market-' + lendingMarketAddress.toBase58() + '.json', JSON.stringify(lendingMarketConfigForFile, null, 2));
+    });
+    commands
+        .command('compute-alloc')
+        .requiredOption('--vault <string>', 'Vault address')
+        .action(async ({ vault }) => {
+        const env = initializeClient(false, false);
+        const vaultAddress = new web3_js_1.PublicKey(vault);
+        const slotDuration = await (0, lib_1.getMedianSlotDurationInMsFromLastEpochs)();
+        const kaminoManager = new lib_1.KaminoManager(env.connection, slotDuration, env.kLendProgramId, env.kVaultProgramId);
+        const vaultState = await new lib_1.KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+        const computedAllocation = await kaminoManager.getVaultComputedReservesAllocation(vaultState);
+        console.log('computedAllocation', computedAllocation);
+    });
+    commands
+        .command('download-lending-market-config-and-all-reserves-configs')
+        .requiredOption('--lending-market <string>', 'Lending Market Address')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ lendingMarket, staging }) => {
+        const env = initializeClient(false, staging);
+        const decoder = new TextDecoder('utf-8');
+        const lendingMarketAddress = new web3_js_1.PublicKey(lendingMarket);
+        const kaminoMarket = await lib_1.KaminoMarket.load(env.connection, lendingMarketAddress, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId);
+        if (!kaminoMarket) {
+            throw new Error('Lending Market not found');
+        }
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        fs.mkdirSync('./configs/' + lendingMarketAddress.toBase58(), { recursive: true });
+        const lendingMarketConfigForFile = lendingMarketState.toJSON();
+        fs.writeFileSync('./configs/' + lendingMarketAddress.toBase58() + '/market-' + lendingMarketAddress.toBase58() + '.json', JSON.stringify(lendingMarketConfigForFile, null, 2));
+        kaminoMarket.reserves.forEach(async (reserve) => {
+            const reserveState = reserve.state;
+            const reserveName = decoder.decode(Uint8Array.from(reserveState.config.tokenInfo.name)).replace(/\0/g, '');
+            const reserveConfigDisplay = parseReserveConfigToFile(reserveState.config);
+            fs.writeFileSync('./configs/' + lendingMarketAddress.toBase58() + '/' + reserveName + '.json', JSON.stringify(reserveConfigDisplay, null, 2));
+        });
+    });
+    commands
+        .command('update-lending-market-from-config')
+        .requiredOption('--lending-market <string>', 'Lending Market address')
+        .requiredOption('--lending-market-config-path <string>', 'Path for the market config')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ lendingMarket, lendingMarketConfigPath, mode, staging }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const lendingMarketAddress = new web3_js_1.PublicKey(lendingMarket);
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        const marketWithAddress = {
+            address: lendingMarketAddress,
+            state: lendingMarketState,
+        };
+        if (mode === 'multisig') {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const newLendingMarket = lib_1.LendingMarket.fromJSON(JSON.parse(fs.readFileSync(lendingMarketConfigPath, 'utf8')));
+        const ixs = kaminoManager.updateLendingMarketIxs(marketWithAddress, newLendingMarket);
+        // executing 6 ixs in a txn to make sure they fit
+        for (let ixnIndex = 0; ixnIndex < ixs.length; ixnIndex += 6) {
+            const ixnToExecute = ixs.slice(ixnIndex, ixnIndex + 6);
+            const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixnToExecute, mode, 2500, [], 400_000);
+        }
+        mode === 'execute' &&
+            console.log('Reserve Updated with new config -> ', JSON.parse(JSON.stringify(newLendingMarket)));
+    });
+    commands
+        .command('update-lending-market-owner')
+        .requiredOption('--lending-market <string>', 'Lending Market address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ lendingMarket, mode, staging }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const lendingMarketAddress = new web3_js_1.PublicKey(lendingMarket);
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        const marketWithAddress = {
+            address: lendingMarketAddress,
+            state: lendingMarketState,
+        };
+        if (mode === 'multisig') {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const ix = kaminoManager.updateLendingMarketOwnerIxs(marketWithAddress);
+        const _updateLendingMarketSig = await processTxn(env.client, env.payer, [ix], mode, 2500, [], 400_000);
+        mode === 'execute' &&
+            console.log('Lending market admin updated to the new admin -> ', JSON.parse(JSON.stringify(lendingMarketState.lendingMarketOwnerCached)));
+    });
+    commands
+        .command('update-lending-market-name')
+        .requiredOption('--lending-market <string>', 'Lending Market address')
+        .requiredOption('--new-name <string>', 'Lending Market address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ lendingMarket, newName, mode, staging }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const lendingMarketAddress = new web3_js_1.PublicKey(lendingMarket);
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        const marketWithAddress = {
+            address: lendingMarketAddress,
+            state: lendingMarketState,
+        };
+        if (mode === 'multisig') {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const currentName = (0, lib_1.parseZeroPaddedUtf8)(lendingMarketState.name);
+        const newNameEncoded = (0, lib_1.encodeTokenName)(newName);
+        console.log('Current name: ', currentName, ' encoded: ', lendingMarketState.name);
+        console.log('New name: ', newName, ' encoded: ', newNameEncoded);
+        // @ts-ignore
+        const newLendingMarket = {
+            ...lendingMarketState,
+            name: newNameEncoded,
+        };
+        const ixs = kaminoManager.updateLendingMarketIxs(marketWithAddress, newLendingMarket);
+        const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+        mode === 'execute' &&
+            console.log('Lending market name updated to -> ', JSON.parse(JSON.stringify(lendingMarketState.lendingMarketOwnerCached)));
+    });
+    commands
+        .command('update-reserve-config-debt-cap')
+        .requiredOption('--reserve <string>', 'Lending Market address')
+        .requiredOption(`--mode <string>`, 'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage')
+        .option(`--staging`, 'If true, will use the staging programs')
+        .action(async ({ reserve, mode, staging }) => {
+        const env = initializeClient(mode === 'multisig', staging);
+        const reserveAddress = new web3_js_1.PublicKey(reserve);
+        const reserveState = await lib_1.Reserve.fetch(env.connection, reserveAddress, env.kLendProgramId);
+        if (!reserveState) {
+            throw new Error('Reserve not found');
+        }
+        const lendingMarketAddress = reserveState.lendingMarket;
+        const lendingMarketState = await lib_1.LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+        if (!lendingMarketState) {
+            throw new Error('Lending Market not found');
+        }
+        const marketWithAddress = {
+            address: lendingMarketAddress,
+            state: lendingMarketState,
+        };
+        if (mode === 'multisig') {
+            throw new Error('If using multisig mode, multisig is required');
+        }
+        const kaminoManager = new lib_1.KaminoManager(env.connection, lib_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.kLendProgramId, env.kVaultProgramId);
+        const newReserveConfigFields = {
+            ...reserveState.config,
+            borrowLimit: new anchor_1.BN(1000),
+        };
+        const newReserveConfig = new types_1.ReserveConfig(newReserveConfigFields);
+        const ixs = await kaminoManager.updateReserveIxs(marketWithAddress, reserveAddress, newReserveConfig);
+        const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+        mode === 'execute' &&
+            console.log('Lending market name updated to -> ', JSON.parse(JSON.stringify(lendingMarketState.lendingMarketOwnerCached)));
+    });
+    commands
+        .command('get-market-or-vault-admin-info')
+        .requiredOption('--address <string>', 'Address of the market or vault')
+        .action(async ({ address }) => {
+        const env = initializeClient(false, false);
+        const adminInfo = await lib_1.KaminoManager.getMarketOrVaultAdminInfo(env.connection, new web3_js_1.PublicKey(address));
+        console.log(adminInfo);
+    });
+    await commands.parseAsync();
+}
+main()
+    .then(() => {
+    process.exit();
+})
+    .catch((e) => {
+    console.error('\n\nKamino CLI exited with error:\n\n', e);
+    process.exit(1);
+});
+function parseKeypairFile(file) {
+    return web3_js_1.Keypair.fromSecretKey(Buffer.from(JSON.parse(require('fs').readFileSync(file))));
+}
+function initializeClient(multisig, staging) {
+    const admin = process.env.ADMIN;
+    const rpc = process.env.RPC;
+    const kLendProgramId = staging ? process.env.KLEND_PROGRAM_ID_STAGING : process.env.KLEND_PROGRAM_ID_MAINNET;
+    const kVaultProgramId = staging ? process.env.KVAULT_PROGRAM_ID_STAGING : process.env.KVAULT_PROGRAM_ID_MAINNET;
+    // Get connection first
+    const env = setUpProgram({
+        adminFilePath: admin,
+        rpc: rpc,
+        kLendProgramId: new web3_js_1.PublicKey(kLendProgramId),
+        kVaultProgramId: new web3_js_1.PublicKey(kVaultProgramId),
+    });
+    !multisig && console.log('\nSettings ⚙️');
+    !multisig && console.log('Admin:', admin);
+    !multisig && console.log('Rpc:', rpc);
+    !multisig && console.log('kLendProgramId:', kLendProgramId);
+    !multisig && console.log('kVaultProgramId:', kVaultProgramId);
+    return env;
+}
+function setUpProgram(args) {
+    const chain = {
+        name: 'mainnet-beta',
+        endpoint: args.rpc,
+        wsEndpoint: args.rpc,
+        chainID: lib_1.MAINNET_BETA_CHAIN_ID,
+        displayName: 'Mainnet Beta (Triton)',
+    };
+    const client = new lib_1.Web3Client(chain);
+    const connection = client.sendConnection;
+    const payer = parseKeypairFile(args.adminFilePath);
+    const wallet = new anchor.Wallet(payer);
+    const provider = new anchor.AnchorProvider(connection, wallet, anchor.AnchorProvider.defaultOptions());
+    return {
+        provider,
+        payer,
+        client,
+        connection,
+        kLendProgramId: args.kLendProgramId,
+        kVaultProgramId: args.kVaultProgramId,
+    };
+}
+async function processTxn(web3Client, admin, ixs, mode, priorityFeeMultiplier = 2500, extraSigners, computeUnits = 200_000, priorityFeeLamports = 1000, luts = []) {
+    if (mode !== 'inspect' && mode !== 'simulate' && mode !== 'execute' && mode !== 'multisig') {
+        throw new Error('Invalid mode: ' + mode + '. Must be one of: inspect/simulate/execute/multisig');
+    }
+    if (mode === 'multisig') {
+        const { blockhash } = await web3Client.connection.getLatestBlockhash();
+        for (const ix of ixs) {
+            const txn = new web3_js_1.Transaction();
+            txn.add(ix);
+            txn.recentBlockhash = blockhash;
+            txn.feePayer = admin.publicKey;
+            console.log(`${(0, base58_js_1.binary_to_base58)(txn.serializeMessage())} \n`);
+        }
+        return '';
+    }
+    else {
+        const microLamport = priorityFeeLamports * 10 ** 6; // 1000 lamports
+        const microLamportsPrioritizationFee = microLamport / computeUnits;
+        const { blockhash } = await web3Client.connection.getLatestBlockhash();
+        if (priorityFeeMultiplier) {
+            const priorityFeeIxn = createAddExtraComputeUnitFeeTransaction(computeUnits, microLamportsPrioritizationFee * priorityFeeMultiplier);
+            ixs.push(...priorityFeeIxn);
+        }
+        const tx = new web3_js_1.TransactionMessage({
+            payerKey: admin.publicKey,
+            recentBlockhash: blockhash,
+            instructions: ixs,
+        }).compileToV0Message(await (0, lib_1.getLookupTableAccounts)(web3Client.connection, luts));
+        if (mode === 'execute') {
+            return await (0, lib_1.signSendAndConfirmRawTransactionWithRetry)({
+                mainConnection: web3Client.sendConnection,
+                extraConnections: [],
+                tx: new web3_js_1.VersionedTransaction(tx),
+                signers: [admin, ...extraSigners],
+                commitment: 'confirmed',
+                sendTransactionOptions: {
+                    skipPreflight: true,
+                    preflightCommitment: 'confirmed',
+                },
+            });
+        }
+        else if (mode === 'simulate') {
+            const simulation = await web3Client.sendConnection.simulateTransaction(new web3_js_1.VersionedTransaction(tx));
+            if (simulation.value.logs && simulation.value.logs.length > 0) {
+                console.log('Simulation: \n' + simulation.value.logs);
+            }
+            else {
+                console.log('Simulation failed: \n' + simulation.value.err);
+            }
+        }
+        else if (mode === 'inspect') {
+            console.log('Tx in B64', `https://explorer.solana.com/tx/inspector?message=${encodeURIComponent(Buffer.from(tx.serialize()).toString('base64'))}`);
+        }
+        return '';
+    }
+}
+function createAddExtraComputeUnitFeeTransaction(units, microLamports) {
+    const ixs = [];
+    ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units }));
+    ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: new decimal_js_1.default(microLamports).floor().toNumber() }));
+    return ixs;
+}
+function parseReserveConfigFromFile(reserveConfigFromFile) {
+    const reserveConfigFields = {
+        status: reserveConfigFromFile.status,
+        loanToValuePct: reserveConfigFromFile.loanToValuePct,
+        liquidationThresholdPct: reserveConfigFromFile.liquidationThresholdPct,
+        minLiquidationBonusBps: reserveConfigFromFile.minLiquidationBonusBps,
+        protocolLiquidationFeePct: reserveConfigFromFile.protocolLiquidationFeePct,
+        protocolOrderExecutionFeePct: reserveConfigFromFile.protocolOrderExecutionFeePct,
+        protocolTakeRatePct: reserveConfigFromFile.protocolTakeRatePct,
+        assetTier: reserveConfigFromFile.assetTier,
+        maxLiquidationBonusBps: reserveConfigFromFile.maxLiquidationBonusBps,
+        badDebtLiquidationBonusBps: reserveConfigFromFile.badDebtLiquidationBonusBps,
+        fees: {
+            borrowFeeSf: fraction_1.Fraction.fromDecimal(new decimal_js_1.default(reserveConfigFromFile.fees.borrowFee)).valueSf,
+            flashLoanFeeSf: fraction_1.Fraction.fromDecimal(new decimal_js_1.default(reserveConfigFromFile.fees.flashLoanFee)).valueSf,
+            padding: Array(8).fill(0),
+        },
+        depositLimit: new anchor_1.BN(reserveConfigFromFile.depositLimit),
+        borrowLimit: new anchor_1.BN(reserveConfigFromFile.borrowLimit),
+        tokenInfo: {
+            name: (0, lib_1.encodeTokenName)(reserveConfigFromFile.tokenInfo.name),
+            heuristic: new types_1.PriceHeuristic({
+                lower: new anchor_1.BN(reserveConfigFromFile.tokenInfo.heuristic.lower),
+                upper: new anchor_1.BN(reserveConfigFromFile.tokenInfo.heuristic.upper),
+                exp: new anchor_1.BN(reserveConfigFromFile.tokenInfo.heuristic.exp),
+            }),
+            maxTwapDivergenceBps: new anchor_1.BN(reserveConfigFromFile.tokenInfo.maxTwapDivergenceBps),
+            maxAgePriceSeconds: new anchor_1.BN(reserveConfigFromFile.tokenInfo.maxAgePriceSeconds),
+            maxAgeTwapSeconds: new anchor_1.BN(reserveConfigFromFile.tokenInfo.maxAgeTwapSeconds),
+            ...parseOracleConfiguration(reserveConfigFromFile),
+            blockPriceUsage: reserveConfigFromFile.tokenInfo.blockPriceUsage,
+            reserved: Array(7).fill(0),
+            padding: Array(19).fill(new anchor_1.BN(0)),
+        },
+        borrowRateCurve: parseBorrowRateCurve(reserveConfigFromFile),
+        depositWithdrawalCap: new types_1.WithdrawalCaps({
+            configCapacity: new anchor_1.BN(reserveConfigFromFile.depositWithdrawalCap.configCapacity),
+            currentTotal: new anchor_1.BN(0),
+            lastIntervalStartTimestamp: new anchor_1.BN(0),
+            configIntervalLengthSeconds: new anchor_1.BN(reserveConfigFromFile.depositWithdrawalCap.configIntervalLengthSeconds),
+        }),
+        debtWithdrawalCap: new types_1.WithdrawalCaps({
+            configCapacity: new anchor_1.BN(reserveConfigFromFile.debtWithdrawalCap.configCapacity),
+            currentTotal: new anchor_1.BN(0),
+            lastIntervalStartTimestamp: new anchor_1.BN(0),
+            configIntervalLengthSeconds: new anchor_1.BN(reserveConfigFromFile.debtWithdrawalCap.configIntervalLengthSeconds),
+        }),
+        deleveragingMarginCallPeriodSecs: new anchor_1.BN(reserveConfigFromFile.deleveragingMarginCallPeriodSecs),
+        borrowFactorPct: new anchor_1.BN(reserveConfigFromFile.borrowFactorPct),
+        elevationGroups: reserveConfigFromFile.elevationGroups,
+        deleveragingThresholdDecreaseBpsPerDay: new anchor_1.BN(reserveConfigFromFile.deleveragingThresholdDecreaseBpsPerDay),
+        disableUsageAsCollOutsideEmode: reserveConfigFromFile.disableUsageAsCollOutsideEmode,
+        utilizationLimitBlockBorrowingAbovePct: reserveConfigFromFile.utilizationLimitBlockBorrowingAbovePct,
+        hostFixedInterestRateBps: reserveConfigFromFile.hostFixedInterestRateBps,
+        autodeleverageEnabled: reserveConfigFromFile.autodeleverageEnabled,
+        borrowLimitOutsideElevationGroup: new anchor_1.BN(reserveConfigFromFile.borrowLimitOutsideElevationGroup),
+        borrowLimitAgainstThisCollateralInElevationGroup: parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile),
+        deleveragingBonusIncreaseBpsPerDay: new anchor_1.BN(reserveConfigFromFile.deleveragingBonusIncreaseBpsPerDay),
+        reserved1: Array(1).fill(0),
+        reserved2: Array(9).fill(0),
+    };
+    return new types_1.ReserveConfig(reserveConfigFields);
+}
+function parseOracleConfiguration(reserveConfigFromFile) {
+    const pythConfiguration = new types_2.PythConfiguration({
+        price: new web3_js_1.PublicKey(reserveConfigFromFile.tokenInfo.pythConfiguration.price),
+    });
+    const switchboardConfiguration = new types_2.SwitchboardConfiguration({
+        priceAggregator: new web3_js_1.PublicKey(reserveConfigFromFile.tokenInfo.switchboardConfiguration.priceAggregator),
+        twapAggregator: new web3_js_1.PublicKey(reserveConfigFromFile.tokenInfo.switchboardConfiguration.twapAggregator),
+    });
+    const priceChain = [65535, 65535, 65535, 65535];
+    const twapChain = [65535, 65535, 65535, 65535];
+    const priceChainFromFile = reserveConfigFromFile.tokenInfo.scopeConfiguration.priceChain;
+    const twapChainFromFile = reserveConfigFromFile.tokenInfo.scopeConfiguration.twapChain;
+    priceChainFromFile.forEach((value, index) => (priceChain[index] = value));
+    twapChainFromFile.forEach((value, index) => (twapChain[index] = value));
+    const scopeConfiguration = new types_1.ScopeConfiguration({
+        priceFeed: new web3_js_1.PublicKey(reserveConfigFromFile.tokenInfo.scopeConfiguration.priceFeed),
+        priceChain: priceChain,
+        twapChain: twapChain,
+    });
+    return {
+        pythConfiguration,
+        switchboardConfiguration,
+        scopeConfiguration,
+    };
+}
+function parseBorrowRateCurve(reserveConfigFromFile) {
+    const curvePoints = [];
+    reserveConfigFromFile.borrowRateCurve.points.forEach((curvePoint) => curvePoints.push({
+        utilizationRateBps: curvePoint.utilizationRateBps,
+        borrowRateBps: curvePoint.borrowRateBps,
+    }));
+    const finalCurvePoints = Array(11).fill(curvePoints[curvePoints.length - 1]);
+    curvePoints.forEach((curvePoint, index) => (finalCurvePoints[index] = curvePoint));
+    const borrowRateCurve = new types_1.BorrowRateCurve({ points: finalCurvePoints });
+    return borrowRateCurve;
+}
+function parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile) {
+    const reserveBorrowLimitAgainstCollInEmode = Array(32).fill(new anchor_1.BN(0));
+    reserveConfigFromFile.borrowLimitAgainstThisCollateralInElevationGroup.forEach((limit, index) => (reserveBorrowLimitAgainstCollInEmode[index] = new anchor_1.BN(limit)));
+    return reserveBorrowLimitAgainstCollInEmode;
+}
+function parseReserveConfigToFile(reserveConfig) {
+    const decoder = new TextDecoder('utf-8');
+    return {
+        status: reserveConfig.status,
+        loanToValuePct: reserveConfig.loanToValuePct,
+        liquidationThresholdPct: reserveConfig.liquidationThresholdPct,
+        minLiquidationBonusBps: reserveConfig.minLiquidationBonusBps,
+        protocolLiquidationFeePct: reserveConfig.protocolLiquidationFeePct,
+        protocolOrderExecutionFeePct: reserveConfig.protocolOrderExecutionFeePct,
+        protocolTakeRatePct: reserveConfig.protocolTakeRatePct,
+        assetTier: reserveConfig.assetTier,
+        maxLiquidationBonusBps: reserveConfig.maxLiquidationBonusBps,
+        badDebtLiquidationBonusBps: reserveConfig.badDebtLiquidationBonusBps,
+        fees: {
+            borrowFee: new fraction_1.Fraction(reserveConfig.fees.borrowFeeSf).toDecimal().toString(),
+            flashLoanFee: new fraction_1.Fraction(reserveConfig.fees.flashLoanFeeSf).toDecimal().toString(),
+            padding: Array(8).fill(0),
+        },
+        depositLimit: reserveConfig.depositLimit.toString(),
+        borrowLimit: reserveConfig.borrowLimit.toString(),
+        tokenInfo: {
+            name: decoder.decode(Uint8Array.from(reserveConfig.tokenInfo.name)).replace(/\0/g, ''),
+            heuristic: {
+                exp: reserveConfig.tokenInfo.heuristic.exp.toString(),
+                lower: reserveConfig.tokenInfo.heuristic.lower.toString(),
+                upper: reserveConfig.tokenInfo.heuristic.upper.toString(),
+            },
+            maxTwapDivergenceBps: reserveConfig.tokenInfo.maxTwapDivergenceBps.toString(),
+            maxAgePriceSeconds: reserveConfig.tokenInfo.maxAgePriceSeconds.toString(),
+            maxAgeTwapSeconds: reserveConfig.tokenInfo.maxAgeTwapSeconds.toString(),
+            scopeConfiguration: reserveConfig.tokenInfo.scopeConfiguration,
+            switchboardConfiguration: reserveConfig.tokenInfo.switchboardConfiguration,
+            pythConfiguration: reserveConfig.tokenInfo.pythConfiguration,
+            blockPriceUsage: reserveConfig.tokenInfo.blockPriceUsage,
+        },
+        borrowRateCurve: reserveConfig.borrowRateCurve,
+        depositWithdrawalCap: reserveConfig.depositWithdrawalCap,
+        debtWithdrawalCap: reserveConfig.debtWithdrawalCap,
+        deleveragingMarginCallPeriodSecs: reserveConfig.deleveragingMarginCallPeriodSecs.toString(),
+        borrowFactorPct: reserveConfig.borrowFactorPct.toString(),
+        elevationGroups: reserveConfig.elevationGroups,
+        deleveragingThresholdDecreaseBpsPerDay: reserveConfig.deleveragingThresholdDecreaseBpsPerDay.toString(),
+        disableUsageAsCollOutsideEmode: reserveConfig.disableUsageAsCollOutsideEmode,
+        utilizationLimitBlockBorrowingAbovePct: reserveConfig.utilizationLimitBlockBorrowingAbovePct,
+        hostFixedInterestRateBps: reserveConfig.hostFixedInterestRateBps,
+        autodeleverageEnabled: reserveConfig.autodeleverageEnabled,
+        borrowLimitOutsideElevationGroup: reserveConfig.borrowLimitOutsideElevationGroup.toString(),
+        borrowLimitAgainstThisCollateralInElevationGroup: reserveConfig.borrowLimitAgainstThisCollateralInElevationGroup.map((entry) => entry.toString()),
+        deleveragingBonusIncreaseBpsPerDay: reserveConfig.deleveragingBonusIncreaseBpsPerDay.toString(),
+        reserved1: Array(2).fill(0),
+        reserved2: Array(9).fill(0),
+    };
+}
+async function createUpdateReserveConfigLutIxs(env, lendingMarketAddress, reserveAddress) {
+    const [globalConfigAddress] = (0, lib_1.globalConfigPda)(lib_1.PROGRAM_ID);
+    const contents = [globalConfigAddress, lendingMarketAddress, reserveAddress];
+    const [createIx, lut] = await (0, lib_1.createLookupTableIx)(env.connection, env.payer.publicKey);
+    const extendIxs = (0, lib_1.extendLookupTableIxs)(env.payer.publicKey, lut, contents);
+    return [lut, [createIx, ...extendIxs]];
+}
+//# sourceMappingURL=client_kamino_manager.js.map