@kamino-finance/klend-sdk 5.3.0 → 5.4.0

package/src/classes/manager.ts

@@ -495,20 +495,18 @@ export class KaminoManager {
 
   /**
    * 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(useOptimisedRPCCall: boolean = true): Promise<KaminoVault[]> {
-    return this._vaultClient.getAllVaults(useOptimisedRPCCall);
+  async getAllVaults(): Promise<KaminoVault[]> {
+    return this._vaultClient.getAllVaults();
   }
 
   /**
    * Get all vaults for owner
    * @param owner the pubkey of the vaults owner
-   * @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 owned by a given pubkey
    */
-  async getAllVaultsForOwner(owner: PublicKey, useOptimisedRPCCall: boolean = true): Promise<KaminoVault[]> {
+  async getAllVaultsForOwner(owner: PublicKey): Promise<KaminoVault[]> {
     const filters = [
       {
         dataSize: VaultState.layout.span + 8,
@@ -527,16 +525,15 @@ export class KaminoManager {
       },
     ];
 
-    let kaminoVaults: GetProgramAccountsResponse = [];
-
-    if (useOptimisedRPCCall) {
-      kaminoVaults = await getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+    const kaminoVaults: GetProgramAccountsResponse = await getProgramAccounts(
+      this._connection,
+      this._kaminoVaultProgramId,
+      VaultState.layout.span + 8,
+      {
         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/classes/market.ts

@@ -1,4 +1,4 @@
-import { AccountInfo, Connection, GetProgramAccountsResponse, PublicKey } from '@solana/web3.js';
+import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
 import { KaminoObligation } from './obligation';
 import { KaminoReserve } from './reserve';
 import { LendingMarket, Obligation, UserMetadata, ReferrerTokenState, Reserve } from '../idl_codegen/accounts';
@@ -531,9 +531,8 @@ export class KaminoMarket {
    * This function will likely require an RPC capable of returning more than the default 100k rows in a single scan
    *
    * @param tag
-   * @param useOptimisedRPCCall - use the optimised RPC call (compressed) to get all obligations
    */
-  async getAllObligationsForMarket(tag?: number, useOptimisedRPCCall: boolean = true): Promise<KaminoObligation[]> {
+  async getAllObligationsForMarket(tag?: number): Promise<KaminoObligation[]> {
     const filters = [
       {
         dataSize: Obligation.layout.span + 8,
@@ -558,26 +557,14 @@ export class KaminoMarket {
     const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
     const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
 
-    let obligations: GetProgramAccountsResponse = [];
-    let slot = 0;
-    const slotPromise = this.connection.getSlot();
-
-    if (useOptimisedRPCCall) {
-      [slot, obligations] = await Promise.all([
-        slotPromise,
-        getProgramAccounts(this.connection, this.programId, {
-          commitment: this.connection.commitment ?? 'processed',
-          filters,
-          dataSlice: { offset: 0, length: ObligationZP.layout.span + 8 }, // truncate the padding
-        }),
-      ]);
-    } else {
-      const obligationsPromise = this.connection.getProgramAccounts(this.programId, {
+    const [slot, obligations] = await Promise.all([
+      this.connection.getSlot(),
+      getProgramAccounts(this.connection, this.programId, ObligationZP.layout.span + 8, {
+        commitment: this.connection.commitment ?? 'processed',
         filters,
         dataSlice: { offset: 0, length: ObligationZP.layout.span + 8 }, // truncate the padding
-      });
-      [slot, obligations] = await Promise.all([slotPromise, obligationsPromise]);
-    }
+      }),
+    ]);
 
     return obligations.map((obligation) => {
       if (obligation.account === null) {

package/src/classes/vault.ts

@@ -1349,16 +1349,14 @@ export class KaminoVaultClient {
    * @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 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>,
-    useOptimisedRPCCall: boolean = true
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<PubkeyHashMap<PublicKey, Decimal>> {
-    const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults(useOptimisedRPCCall);
+    const vaults = vaultsOverride ? vaultsOverride : await this.getAllVaults();
     const vaultTokensPerShare = new PubkeyHashMap<PublicKey, Decimal>();
     for (const vault of vaults) {
       const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot, vaultReservesMap);
@@ -1370,10 +1368,9 @@ 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(useOptimisedRPCCall: boolean = true): Promise<KaminoVault[]> {
+  async getAllVaults(): Promise<KaminoVault[]> {
     const filters = [
       {
         dataSize: VaultState.layout.span + 8,
@@ -1386,16 +1383,15 @@ export class KaminoVaultClient {
       },
     ];
 
-    let kaminoVaults: GetProgramAccountsResponse = [];
-
-    if (useOptimisedRPCCall) {
-      kaminoVaults = await getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+    const kaminoVaults: GetProgramAccountsResponse = await getProgramAccounts(
+      this._connection,
+      this._kaminoVaultProgramId,
+      VaultState.layout.span + 8,
+      {
         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

@@ -922,7 +922,7 @@ async function main() {
     const env = initializeClient(false, false);
     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
-    const allVaults = await kaminoManager.getAllVaults(true);
+    const allVaults = await kaminoManager.getAllVaults();
     console.log('all vaults', allVaults);
   });
 

package/src/utils/rpc.ts

@@ -9,11 +9,12 @@ import {
 } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import axios from 'axios';
-import { init, decompress } from '@bokuweb/zstd-wasm';
 import { v4 as uuidv4 } from 'uuid';
+import { ZSTDDecoder } from 'zstddec';
 
+const decoder = new ZSTDDecoder();
 (async () => {
-  await init();
+  await decoder.init();
 })();
 
 /**
@@ -21,11 +22,13 @@ import { v4 as uuidv4 } from 'uuid';
  * Uses axios instead of node-fetch to work around a bug in node-fetch that causes subsequent requests with different encoding to fail
  * @param connection
  * @param programId
+ * @param structSize - the size of the decompressed account data struct
  * @param configOrCommitment
  */
 export async function getProgramAccounts(
   connection: Connection,
   programId: PublicKey,
+  structSize: number,
   configOrCommitment?: GetProgramAccountsConfig | Commitment
 ): Promise<GetProgramAccountsResponse> {
   const programIdStr = programId.toBase58();
@@ -65,7 +68,7 @@ export async function getProgramAccounts(
 
   const res = unsafeRes as RpcResult;
   const deser = res.result.map(async (account) => ({
-    account: await deserializeAccountInfo(account.account),
+    account: await deserializeAccountInfo(account.account, structSize),
     pubkey: new PublicKey(account.pubkey),
   }));
   const x = await Promise.all(deser);
@@ -80,8 +83,8 @@ export async function getAccountOwner(connection: Connection, address: PublicKey
   return acc.owner;
 }
 
-async function deserializeAccountInfo(accountInfo: AccountInfo<string[]>): Promise<AccountInfo<Buffer>> {
-  const data = decompress(Buffer.from(accountInfo.data[0], 'base64'));
+async function deserializeAccountInfo(accountInfo: AccountInfo<string[]>, size: number): Promise<AccountInfo<Buffer>> {
+  const data = decoder.decode(Buffer.from(accountInfo.data[0], 'base64'), size);
   return {
     owner: accountInfo.owner,
     lamports: accountInfo.lamports,