@kamino-finance/klend-sdk 6.0.5-beta.5 → 6.0.5

package/src/utils/accountListing.ts

@@ -1,79 +1,93 @@
-import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
-import { LendingMarket, Obligation, Reserve } from '../idl_codegen/accounts';
-import { PROGRAM_ID } from '../idl_codegen/programId';
-import bs58 from 'bs58';
+import { Address, Base58EncodedBytes, getBase58Decoder, GetProgramAccountsApi, Rpc } from '@solana/kit';
+import { LendingMarket, Obligation, Reserve } from '../@codegen/klend/accounts';
+import { PROGRAM_ID } from '../@codegen/klend/programId';
+
+const base58Decoder = getBase58Decoder();
 
 export async function* getAllObligationAccounts(
-  connection: Connection
-): AsyncGenerator<[PublicKey, Obligation], void, unknown> {
+  connection: Rpc<GetProgramAccountsApi>
+): AsyncGenerator<[Address, Obligation], void, unknown> {
   // Poor-man's paging...
   for (let i = 0; i < 256; i++) {
-    const obligations = await connection.getProgramAccounts(PROGRAM_ID, {
-      filters: [
-        {
-          dataSize: Obligation.layout.span + 8,
-        },
-        {
-          memcmp: {
-            offset: 0,
-            bytes: bs58.encode(Obligation.discriminator),
+    const obligations = await connection
+      .getProgramAccounts(PROGRAM_ID, {
+        filters: [
+          {
+            dataSize: BigInt(Obligation.layout.span + 8),
           },
-        },
-        {
-          memcmp: {
-            offset: 64,
-            bytes: bs58.encode([i]), // ...via sharding by userId's first byte (just as a source of randomness)
+          {
+            memcmp: {
+              offset: 0n,
+              bytes: base58Decoder.decode(Obligation.discriminator) as Base58EncodedBytes,
+              encoding: 'base58',
+            },
           },
-        },
-      ],
-    });
+          {
+            memcmp: {
+              offset: 64n,
+              bytes: base58Decoder.decode(Buffer.from([i])) as Base58EncodedBytes, // ...via sharding by userId's first byte (just as a source of randomness)
+              encoding: 'base58',
+            },
+          },
+        ],
+        encoding: 'base64',
+      })
+      .send();
     for (const obligation of obligations) {
-      yield [obligation.pubkey, Obligation.decode(obligation.account.data)];
+      yield [obligation.pubkey, Obligation.decode(Buffer.from(obligation.account.data[0], 'base64'))];
     }
   }
 }
 
 export async function* getAllReserveAccounts(
-  connection: Connection
-): AsyncGenerator<[PublicKey, Reserve, AccountInfo<Buffer>], void, unknown> {
+  rpc: Rpc<GetProgramAccountsApi>
+): AsyncGenerator<[Address, Reserve], void, unknown> {
   // due to relatively low count of reserves, we technically don't really need a generator, but let's keep it consistent within this file
-  const reserves = await connection.getProgramAccounts(PROGRAM_ID, {
-    filters: [
-      {
-        dataSize: Reserve.layout.span + 8,
-      },
-      {
-        memcmp: {
-          offset: 0,
-          bytes: bs58.encode(Reserve.discriminator),
+  const reserves = await rpc
+    .getProgramAccounts(PROGRAM_ID, {
+      filters: [
+        {
+          dataSize: BigInt(Reserve.layout.span + 8),
         },
-      },
-    ],
-  });
+        {
+          memcmp: {
+            offset: 0n,
+            bytes: base58Decoder.decode(Reserve.discriminator) as Base58EncodedBytes,
+            encoding: 'base58',
+          },
+        },
+      ],
+      encoding: 'base64',
+    })
+    .send();
   for (const reserve of reserves) {
-    yield [reserve.pubkey, Reserve.decode(reserve.account.data), reserve.account];
+    yield [reserve.pubkey, Reserve.decode(Buffer.from(reserve.account.data[0], 'base64'))];
   }
 }
 
 export async function* getAllLendingMarketAccounts(
-  connection: Connection,
-  programId: PublicKey = PROGRAM_ID
-): AsyncGenerator<[PublicKey, LendingMarket], void, unknown> {
+  connection: Rpc<GetProgramAccountsApi>,
+  programId: Address = PROGRAM_ID
+): AsyncGenerator<[Address, LendingMarket], void, unknown> {
   // due to relatively very low count of lending markets, we technically don't really need a generator, but let's keep it consistent within this file
-  const lendingMarkets = await connection.getProgramAccounts(programId, {
-    filters: [
-      {
-        dataSize: LendingMarket.layout.span + 8,
-      },
-      {
-        memcmp: {
-          offset: 0,
-          bytes: bs58.encode(LendingMarket.discriminator),
+  const lendingMarkets = await connection
+    .getProgramAccounts(programId, {
+      filters: [
+        {
+          dataSize: BigInt(LendingMarket.layout.span + 8),
+        },
+        {
+          memcmp: {
+            offset: 0n,
+            bytes: base58Decoder.decode(LendingMarket.discriminator) as Base58EncodedBytes,
+            encoding: 'base58',
+          },
         },
-      },
-    ],
-  });
+      ],
+      encoding: 'base64',
+    })
+    .send();
   for (const lendingMarket of lendingMarkets) {
-    yield [lendingMarket.pubkey, LendingMarket.decode(lendingMarket.account.data)];
+    yield [lendingMarket.pubkey, LendingMarket.decode(Buffer.from(lendingMarket.account.data[0], 'base64'))];
   }
 }

package/src/utils/api.ts

@@ -1,4 +1,4 @@
-import { PublicKey } from '@solana/web3.js';
+import { Address } from '@solana/kit';
 import axios from 'axios';
 import { ConfigType, isEmptyObject } from '../classes';
 import { CDN_ENDPOINT, getApiEndpoint } from '../utils';
@@ -6,7 +6,7 @@ import { IBackOffOptions, backOff } from 'exponential-backoff';
 import { PROGRAM_ID } from '../lib';
 
 export type ApiRequestOptions = {
-  programId?: PublicKey;
+  programId?: Address;
   source?: 'API' | 'CDN';
   apiBaseUrl?: string;
 };

package/src/utils/ata.ts

@@ -1,15 +1,29 @@
 import {
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  NATIVE_MINT,
-  TOKEN_PROGRAM_ID,
-  createAssociatedTokenAccountInstruction,
-  createAssociatedTokenAccountIdempotentInstruction as createAtaIx,
-  createCloseAccountInstruction,
-  getAssociatedTokenAddressSync,
-} from '@solana/spl-token';
-import { AccountInfo, Connection, PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+  Address,
+  fetchEncodedAccount,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  GetTokenAccountBalanceApi,
+  IInstruction,
+  Lamports,
+  MaybeAccount,
+  Rpc,
+  TransactionSigner,
+} from '@solana/kit';
 import Decimal from 'decimal.js';
 import { collToLamportsDecimal, DECIMALS_SOL } from '@kamino-finance/kliquidity-sdk/dist';
+import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  findAssociatedTokenPda,
+  getSyncNativeInstruction,
+  getCreateAssociatedTokenIdempotentInstruction,
+  fetchMaybeToken,
+  Token,
+  getCloseAccountInstruction,
+} from '@solana-program/token-2022';
+import { WRAPPED_SOL_MINT } from './pubkey';
+import { getTransferSolInstruction } from '@solana-program/system';
 
 /**
  * Create an idempotent create ATA instruction
@@ -21,57 +35,68 @@ import { collToLamportsDecimal, DECIMALS_SOL } from '@kamino-finance/kliquidity-
  * @param ata - optional ata address - derived if not provided
  * @returns The ATA address public key and the transaction instruction
  */
-export function createAssociatedTokenAccountIdempotentInstruction(
-  owner: PublicKey,
-  mint: PublicKey,
-  payer: PublicKey = owner,
-  tokenProgram: PublicKey = TOKEN_PROGRAM_ID,
-  ata?: PublicKey
-): [PublicKey, TransactionInstruction] {
+export async function createAssociatedTokenAccountIdempotentInstruction(
+  payer: TransactionSigner,
+  mint: Address,
+  owner: Address = payer.address,
+  tokenProgram: Address = TOKEN_PROGRAM_ADDRESS,
+  ata?: Address
+): Promise<[Address, IInstruction]> {
   let ataAddress = ata;
   if (!ataAddress) {
-    ataAddress = getAssociatedTokenAddress(mint, owner, true, tokenProgram, ASSOCIATED_TOKEN_PROGRAM_ID);
+    ataAddress = await getAssociatedTokenAddress(mint, owner, tokenProgram, ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
   }
-  const createUserTokenAccountIx = createAtaIx(
-    payer,
-    ataAddress,
-    owner,
-    mint,
-    tokenProgram,
-    ASSOCIATED_TOKEN_PROGRAM_ID
+  const createUserTokenAccountIx = getCreateAssociatedTokenIdempotentInstruction(
+    {
+      owner,
+      mint,
+      tokenProgram,
+      ata: ataAddress,
+      payer,
+    },
+    {
+      programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    }
   );
   return [ataAddress, createUserTokenAccountIx];
 }
 
-export function getAssociatedTokenAddress(
-  mint: PublicKey,
-  owner: PublicKey,
-  allowOwnerOffCurve = true,
-  programId = TOKEN_PROGRAM_ID,
-  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): PublicKey {
-  if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer())) throw new Error('Token owner off curve');
-
-  const [address] = PublicKey.findProgramAddressSync(
-    [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
-    associatedTokenProgramId
+export async function getAssociatedTokenAddress(
+  mint: Address,
+  owner: Address,
+  tokenProgram: Address = TOKEN_PROGRAM_ADDRESS,
+  associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+): Promise<Address> {
+  const [ata] = await findAssociatedTokenPda(
+    {
+      mint,
+      owner,
+      tokenProgram,
+    },
+    { programAddress: associatedTokenProgramId }
   );
-
-  return address;
+  return ata;
 }
 
 export const getAtasWithCreateIxsIfMissing = async (
-  connection: Connection,
-  user: PublicKey,
-  mints: Array<{ mint: PublicKey; tokenProgram: PublicKey }>
-): Promise<{ atas: PublicKey[]; createAtaIxs: TransactionInstruction[] }> => {
-  const atas: Array<PublicKey> = mints.map((x) => getAssociatedTokenAddress(x.mint, user, true, x.tokenProgram));
-  const accountInfos = await connection.getMultipleAccountsInfo(atas);
-  const createAtaIxs: TransactionInstruction[] = [];
+  rpc: Rpc<GetMultipleAccountsApi>,
+  user: TransactionSigner,
+  mints: Array<{ mint: Address; tokenProgram: Address }>
+): Promise<{ atas: Address[]; createAtaIxs: IInstruction[] }> => {
+  const atas: Array<Address> = await Promise.all(
+    mints.map(async (x) => getAssociatedTokenAddress(x.mint, user.address, x.tokenProgram))
+  );
+  const accountInfos = await rpc.getMultipleAccounts(atas).send();
+  const createAtaIxs: IInstruction[] = [];
   for (let i = 0; i < atas.length; i++) {
-    if (!accountInfos[i]) {
+    if (accountInfos.value[i] === null) {
       const { mint, tokenProgram } = mints[i];
-      const [ata, createIxn] = createAssociatedTokenAccountIdempotentInstruction(user, mint, user, tokenProgram);
+      const [ata, createIxn] = await createAssociatedTokenAccountIdempotentInstruction(
+        user,
+        mint,
+        user.address,
+        tokenProgram
+      );
       atas[i] = ata;
       createAtaIxs.push(createIxn);
     }
@@ -82,16 +107,16 @@ export const getAtasWithCreateIxsIfMissing = async (
   };
 };
 
-export function createAtasIdempotent(
-  user: PublicKey,
-  mints: Array<{ mint: PublicKey; tokenProgram: PublicKey }>
-): Array<{ ata: PublicKey; createAtaIx: TransactionInstruction }> {
-  const res: Array<{ ata: PublicKey; createAtaIx: TransactionInstruction }> = [];
+export async function createAtasIdempotent(
+  user: TransactionSigner,
+  mints: Array<{ mint: Address; tokenProgram: Address }>
+): Promise<Array<{ ata: Address; createAtaIx: IInstruction }>> {
+  const res: Array<{ ata: Address; createAtaIx: IInstruction }> = [];
   for (const mint of mints) {
-    const [ata, createAtaIx] = createAssociatedTokenAccountIdempotentInstruction(
+    const [ata, createAtaIx] = await createAssociatedTokenAccountIdempotentInstruction(
       user,
       mint.mint,
-      user,
+      user.address,
       mint.tokenProgram
     );
     res.push({
@@ -102,91 +127,96 @@ export function createAtasIdempotent(
   return res;
 }
 
-export function getTransferWsolIxs(owner: PublicKey, ata: PublicKey, amountLamports: Decimal) {
-  const ixs: TransactionInstruction[] = [];
+export function getTransferWsolIxs(owner: TransactionSigner, ata: Address, amountLamports: Lamports) {
+  const ixs: IInstruction[] = [];
 
   ixs.push(
-    SystemProgram.transfer({
-      fromPubkey: owner,
-      toPubkey: ata,
-      lamports: amountLamports.toNumber(),
+    getTransferSolInstruction({
+      source: owner,
+      amount: amountLamports,
+      destination: ata,
     })
   );
 
   ixs.push(
-    new TransactionInstruction({
-      keys: [
-        {
-          pubkey: ata,
-          isSigner: false,
-          isWritable: true,
-        },
-      ],
-      data: Buffer.from(new Uint8Array([17])),
-      programId: TOKEN_PROGRAM_ID,
-    })
+    getSyncNativeInstruction(
+      {
+        account: ata,
+      },
+      { programAddress: TOKEN_PROGRAM_ADDRESS }
+    )
   );
 
   return ixs;
 }
 
-export async function getTokenAccountBalance(connection: Connection, tokenAccount: PublicKey): Promise<number> {
-  const tokenAccountBalance = await connection.getTokenAccountBalance(tokenAccount);
+export async function getTokenAccountBalance(
+  connection: Rpc<GetTokenAccountBalanceApi>,
+  tokenAccount: Address
+): Promise<number> {
+  const tokenAccountBalance = await connection.getTokenAccountBalance(tokenAccount).send();
 
   return Number(tokenAccountBalance.value.amount).valueOf();
 }
 
 /// Get the balance of a token account in decimal format (tokens, not lamports)
 export async function getTokenAccountBalanceDecimal(
-  connection: Connection,
-  mint: PublicKey,
-  owner: PublicKey,
-  tokenProgram: PublicKey = TOKEN_PROGRAM_ID
+  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
+  mint: Address,
+  owner: Address,
+  tokenProgram: Address = TOKEN_PROGRAM_ADDRESS
 ): Promise<Decimal> {
-  const ata = getAssociatedTokenAddress(mint, owner, true, tokenProgram);
-  const accInfo = await connection.getAccountInfo(ata);
-  if (accInfo === null) {
+  const ata = await getAssociatedTokenAddress(mint, owner, tokenProgram);
+  const accInfo = await fetchEncodedAccount(rpc, ata);
+  if (!accInfo.exists) {
     return new Decimal('0');
   }
-  const { value } = await connection.getTokenAccountBalance(ata);
+  const { value } = await rpc.getTokenAccountBalance(ata).send();
   return new Decimal(value.uiAmountString!);
 }
 
 export type CreateWsolAtaIxs = {
-  wsolAta: PublicKey;
-  createAtaIxs: TransactionInstruction[];
-  closeAtaIxs: TransactionInstruction[];
+  wsolAta: Address;
+  createAtaIxs: IInstruction[];
+  closeAtaIxs: IInstruction[];
 };
 
 /**
  * Creates a wSOL ata if missing and syncs the balance. If the ata exists and it has more or equal no wrapping happens
- * @param connection - Solana RPC connection (read)
+ * @param rpc - Solana RPC rpc (read)
  * @param amount min amount to have in the wSOL ata. If the ata exists and it has more or equal no wrapping happens
  * @param owner - owner of the ata
  * @returns wsolAta: the keypair of the ata, used to sign the initialization transaction; createAtaIxs: a list with ixs to initialize the ata and wrap SOL if needed; closeAtaIxs: a list with ixs to close the ata
  */
 export const createWsolAtaIfMissing = async (
-  connection: Connection,
+  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
   amount: Decimal,
-  owner: PublicKey
+  owner: TransactionSigner
 ): Promise<CreateWsolAtaIxs> => {
-  const createIxs: TransactionInstruction[] = [];
-  const closeIxs: TransactionInstruction[] = [];
+  const createIxs: IInstruction[] = [];
+  const closeIxs: IInstruction[] = [];
 
-  const wsolAta: PublicKey = getAssociatedTokenAddressSync(NATIVE_MINT, owner, true, TOKEN_PROGRAM_ID);
+  const wsolAta: Address = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address, TOKEN_PROGRAM_ADDRESS);
 
   const solDeposit = amount;
-  const wsolAtaAccountInfo: AccountInfo<Buffer> | null = await connection.getAccountInfo(wsolAta);
-
+  const wsolAtaAccountInfo: MaybeAccount<Token> = await fetchMaybeToken(rpc, wsolAta);
   // This checks if we need to create it
-  if (isWsolInfoInvalid(wsolAtaAccountInfo)) {
-    createIxs.push(createAssociatedTokenAccountInstruction(owner, wsolAta, owner, NATIVE_MINT, TOKEN_PROGRAM_ID));
+  if (wsolAtaAccountInfo.exists) {
+    createIxs.push(
+      getCreateAssociatedTokenIdempotentInstruction({
+        owner: owner.address,
+        payer: owner,
+        ata: wsolAta,
+        mint: WRAPPED_SOL_MINT,
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      })
+    );
   }
 
   let wsolExistingBalanceLamports = new Decimal(0);
   try {
-    if (wsolAtaAccountInfo != null) {
-      const uiAmount = (await getTokenAccountBalanceDecimal(connection, NATIVE_MINT, owner)).toNumber();
+    if (wsolAtaAccountInfo.exists) {
+      const uiAmount = (await getTokenAccountBalanceDecimal(rpc, WRAPPED_SOL_MINT, owner.address)).toNumber();
       wsolExistingBalanceLamports = collToLamportsDecimal(new Decimal(uiAmount), DECIMALS_SOL);
     }
   } catch (err) {
@@ -195,10 +225,10 @@ export const createWsolAtaIfMissing = async (
 
   if (solDeposit !== null && solDeposit.gt(wsolExistingBalanceLamports)) {
     createIxs.push(
-      SystemProgram.transfer({
-        fromPubkey: owner,
-        toPubkey: wsolAta,
-        lamports: BigInt(solDeposit.sub(wsolExistingBalanceLamports).floor().toString()),
+      getTransferSolInstruction({
+        source: owner,
+        destination: wsolAta,
+        amount: BigInt(solDeposit.sub(wsolExistingBalanceLamports).floor().toString()),
       })
     );
   }
@@ -206,21 +236,25 @@ export const createWsolAtaIfMissing = async (
   if (createIxs.length > 0) {
     // Primitive way of wrapping SOL
     createIxs.push(
-      new TransactionInstruction({
-        keys: [
-          {
-            pubkey: wsolAta,
-            isSigner: false,
-            isWritable: true,
-          },
-        ],
-        data: Buffer.from(new Uint8Array([17])),
-        programId: TOKEN_PROGRAM_ID,
-      })
+      getSyncNativeInstruction(
+        {
+          account: wsolAta,
+        },
+        { programAddress: TOKEN_PROGRAM_ADDRESS }
+      )
     );
   }
 
-  closeIxs.push(createCloseAccountInstruction(wsolAta, owner, owner, [], TOKEN_PROGRAM_ID));
+  closeIxs.push(
+    getCloseAccountInstruction(
+      {
+        owner,
+        account: wsolAta,
+        destination: owner.address,
+      },
+      { programAddress: TOKEN_PROGRAM_ADDRESS }
+    )
+  );
 
   return {
     wsolAta,
@@ -228,13 +262,3 @@ export const createWsolAtaIfMissing = async (
     closeAtaIxs: closeIxs,
   };
 };
-
-export const isWsolInfoInvalid = (wsolAtaAccountInfo: any): boolean => {
-  const res =
-    wsolAtaAccountInfo === null ||
-    (wsolAtaAccountInfo !== null &&
-      wsolAtaAccountInfo.data.length === 0 &&
-      wsolAtaAccountInfo.owner.eq(PublicKey.default));
-
-  return res;
-};

package/src/utils/bigint.ts

@@ -0,0 +1,3 @@
+export function maxBigInt(...values: bigint[]): bigint {
+  return values.reduce((max, current) => (current > max ? current : max), values[0]);
+}

package/src/utils/compat.ts

@@ -0,0 +1,17 @@
+import { PublicKey, AccountInfo } from '@solana/web3.js';
+import { Address, Base64EncodedDataResponse, Account } from '@solana/kit';
+import { Buffer } from 'buffer';
+
+export function toLegacyPublicKey(address: Address): PublicKey {
+  return new PublicKey(address.toString());
+}
+
+export function toAccountInfo(acc: Account<Base64EncodedDataResponse>): AccountInfo<Buffer> {
+  return {
+    owner: toLegacyPublicKey(acc.programAddress),
+    data: Buffer.from(acc.data[0], 'base64'),
+    lamports: Number.parseInt(acc.lamports.toString()),
+    executable: acc.executable,
+    rentEpoch: 0,
+  };
+}

package/src/utils/constants.ts

@@ -1,9 +1,9 @@
 import Decimal from 'decimal.js';
-import { PROGRAM_ID } from '../idl_codegen/programId';
-import { PublicKey } from '@solana/web3.js';
+import { PROGRAM_ID } from '../@codegen/klend/programId';
+import { address, Address } from '@solana/kit';
 import BN from 'bn.js';
 
-export const STAGING_PROGRAM_ID: PublicKey = new PublicKey('SLendK7ySfcEzyaFqy93gDnD3RtrpXJcnRwb6zFHJSh');
+export const STAGING_PROGRAM_ID: Address = address('SLendK7ySfcEzyaFqy93gDnD3RtrpXJcnRwb6zFHJSh');
 export const DEFAULT_KLEND_PROGRAM_ID: string = PROGRAM_ID.toString();
 export const U64_MAX = '18446744073709551615';
 const INITIAL_COLLATERAL_RATIO = 1;
@@ -19,8 +19,8 @@ export function isENV(value: any): value is ENV {
   return value === 'mainnet-beta' || value === 'devnet' || value === 'localnet';
 }
 
-export function getApiEndpoint(programId: PublicKey, apiBaseUrl: string = 'https://api.kamino.finance') {
-  if (programId.equals(PROGRAM_ID)) {
+export function getApiEndpoint(programId: Address, apiBaseUrl: string = 'https://api.kamino.finance') {
+  if (programId === PROGRAM_ID) {
     return `${apiBaseUrl}/v2/kamino-market`;
   } else {
     return `${apiBaseUrl}/v2/kamino-market/?programId=${programId.toString()}`;
@@ -75,8 +75,6 @@ export const MIN_AUTODELEVERAGE_BONUS_BPS = 50;
 
 export const SOL_DECIMALS = 9;
 
-export const MAINNET_BETA_CHAIN_ID = 101;
-
 export const BORROWS_LIMIT = 5;
 export const DEPOSITS_LIMIT = 8;
 

package/src/utils/consts.ts

@@ -0,0 +1,5 @@
+import { address, Address } from '@solana/kit';
+
+export const WRAPPED_SOL_MINT: Address = address('So11111111111111111111111111111111111111112');
+
+export const LAMPORTS_PER_SOL = 10 ** 9;

package/src/utils/idl.ts

@@ -1,4 +1,4 @@
 import { Idl } from '@coral-xyz/anchor';
-import rawIdl from '../idl.json';
+import rawIdl from '../idl/klend.json';
 
 export const idl: Idl = rawIdl as Idl;

package/src/utils/index.ts

@@ -11,7 +11,6 @@ export * from './userMetadata';
 export * from './pubkey';
 export * from './oracle';
 export * from './lookupTable';
-export * from './sendTransactionsUtils';
 export * from './managerTypes';
 export * from './fuzz';
 export * from './rpc';