@kamino-finance/klend-sdk 5.1.3 → 5.1.5

package/src/classes/vault.ts

@@ -2,6 +2,7 @@ import { BN } from '@coral-xyz/anchor';
 import {
   AccountMeta,
   Connection,
+  GetProgramAccountsResponse,
   Keypair,
   PublicKey,
   SystemProgram,
@@ -414,12 +415,12 @@ export class KaminoVaultClient {
         ]
       );
       createAtasIxns.push(...createWsolAtaIxns);
-      const depositWsolixn = getDepositWsolIxns(
+      const depositWsolIxn = getDepositWsolIxns(
         user,
         wsolAta[0],
         numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil()
       );
-      createAtasIxns.push(...depositWsolixn);
+      createAtasIxns.push(...depositWsolIxn);
     }
 
     const { atas, createAtaIxs: createSharesAtaIxns } = await getAtasWithCreateIxnsIfMissing(this._connection, user, [
@@ -610,7 +611,6 @@ export class KaminoVaultClient {
     const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const lendingMarketAuth = lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
 
-    // todo: create ata if needed here
     const payerTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, payer);
 
     const investAccounts: InvestAccounts = {
@@ -875,17 +875,19 @@ export class KaminoVaultClient {
 
   /**
    * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
+   * @param vaultsOverride - a list of vaults to get the tokens per share for; if provided with state it will not fetch the state again
+   * @param vaultReservesMap - optional parameter; a hashmap from pubkey to reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
-   * @param vaultsOverride
-   * @param vaultReservesMap
+   * @param useOptimisedRPCCall - if set to true, it will use the optimized getProgramAccounts RPC call, which is more efficient but doesn't work in web environments
    * @returns - token per share value
    */
   async getTokensPerShareAllVaults(
     slot: number,
     vaultsOverride?: Array<KaminoVault>,
-    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    useOptimisedRPCCall: boolean = true
   ): Promise<PubkeyHashMap<PublicKey, Decimal>> {
-    const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
+    const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults(useOptimisedRPCCall);
     const vaultTokensPerShare = new PubkeyHashMap<PublicKey, Decimal>();
     for (const vault of vaults) {
       const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot, vaultReservesMap);
@@ -897,9 +899,10 @@ export class KaminoVaultClient {
 
   /**
    * Get all vaults
+   * @param useOptimisedRPCCall - if set to true, it will use the optimized getProgramAccounts RPC call, which is more efficient but doesn't work in web environments
    * @returns an array of all vaults
    */
-  async getAllVaults(): Promise<KaminoVault[]> {
+  async getAllVaults(useOptimisedRPCCall: boolean = true): Promise<KaminoVault[]> {
     const filters = [
       {
         dataSize: VaultState.layout.span + 8,
@@ -912,10 +915,16 @@ export class KaminoVaultClient {
       },
     ];
 
-    const kaminoVaults = await getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
-      commitment: this._connection.commitment ?? 'processed',
-      filters,
-    });
+    let kaminoVaults: GetProgramAccountsResponse = [];
+
+    if (useOptimisedRPCCall) {
+      kaminoVaults = await getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+        commitment: this._connection.commitment ?? 'processed',
+        filters,
+      });
+    } else {
+      kaminoVaults = await this._connection.getProgramAccounts(this._kaminoVaultProgramId, { filters });
+    }
 
     return kaminoVaults.map((kaminoVault) => {
       if (kaminoVault.account === null) {

package/src/client_kamino_manager.ts

@@ -45,13 +45,13 @@ import Decimal from 'decimal.js';
 import { BN } from '@coral-xyz/anchor';
 import { PythConfiguration, SwitchboardConfiguration } from './idl_codegen_kamino_vault/types';
 import * as fs from 'fs';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { MarketWithAddress } from './utils/managerTypes';
 import {
   ManagementFeeBps,
   PendingVaultAdmin,
   PerformanceFeeBps,
 } from './idl_codegen_kamino_vault/types/VaultConfigField';
+import { getAccountOwner } from './utils/rpc';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -237,10 +237,11 @@ async function main() {
       const multisigPk = multisig ? new PublicKey(multisig) : PublicKey.default;
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
+      const tokenProgramID = await getAccountOwner(env.connection, tokenMint);
       const kaminoVaultConfig = new KaminoVaultConfig({
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
         tokenMint: tokenMint,
-        tokenMintProgramId: TOKEN_PROGRAM_ID,
+        tokenMintProgramId: tokenProgramID,
         performanceFeeRate: new Decimal(0.0),
         managementFeeRate: new Decimal(0.0),
       });
@@ -470,6 +471,67 @@ async function main() {
       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 PublicKey(vault);
+
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+      const instructions = await kaminoManager.depositToVaultIxs(env.payer.publicKey, kaminoVault, amount);
+
+      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+
+      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 PublicKey(vault);
+
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+      const instructions = await kaminoManager.withdrawFromVaultIxs(
+        env.payer.publicKey,
+        kaminoVault,
+        new Decimal(amount),
+        await env.connection.getSlot('confirmed')
+      );
+
+      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+
+      mode === 'execute' && console.log('User withdraw:', depositSig);
+    });
+
   // commands
   //   .command('close-vault')
   //   .requiredOption('--vault <string>', 'Vault address')
@@ -500,7 +562,7 @@ async function main() {
     const env = initializeClient(false, false);
     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
-    const allVaults = await kaminoManager.getAllVaults();
+    const allVaults = await kaminoManager.getAllVaults(true);
     console.log('all vaults', allVaults);
   });
 

package/src/utils/rpc.ts

@@ -72,6 +72,14 @@ export async function getProgramAccounts(
   return x as GetProgramAccountsResponse;
 }
 
+export async function getAccountOwner(connection: Connection, address: PublicKey): Promise<PublicKey> {
+  const acc = await connection.getAccountInfo(address);
+  if (acc == null) {
+    throw Error(`Could not fetch mint ${address.toString()}`);
+  }
+  return acc.owner;
+}
+
 async function deserializeAccountInfo(accountInfo: AccountInfo<string[]>): Promise<AccountInfo<Buffer>> {
   const data = decompress(Buffer.from(accountInfo.data[0], 'base64'));
   return {