@kamino-finance/klend-sdk 5.0.6 → 5.1.0

package/src/idl_codegen_kamino_vault/types/VaultConfigField.ts

@@ -1,270 +1,269 @@
-import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
-import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from "@coral-xyz/borsh"
+import { PublicKey } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh';
 
 export interface PerformanceFeeBpsJSON {
-  kind: "PerformanceFeeBps"
+  kind: 'PerformanceFeeBps';
 }
 
 export class PerformanceFeeBps {
-  static readonly discriminator = 0
-  static readonly kind = "PerformanceFeeBps"
-  readonly discriminator = 0
-  readonly kind = "PerformanceFeeBps"
+  static readonly discriminator = 0;
+  static readonly kind = 'PerformanceFeeBps';
+  readonly discriminator = 0;
+  readonly kind = 'PerformanceFeeBps';
 
   toJSON(): PerformanceFeeBpsJSON {
     return {
-      kind: "PerformanceFeeBps",
-    }
+      kind: 'PerformanceFeeBps',
+    };
   }
 
   toEncodable() {
     return {
       PerformanceFeeBps: {},
-    }
+    };
   }
 }
 
 export interface ManagementFeeBpsJSON {
-  kind: "ManagementFeeBps"
+  kind: 'ManagementFeeBps';
 }
 
 export class ManagementFeeBps {
-  static readonly discriminator = 1
-  static readonly kind = "ManagementFeeBps"
-  readonly discriminator = 1
-  readonly kind = "ManagementFeeBps"
+  static readonly discriminator = 1;
+  static readonly kind = 'ManagementFeeBps';
+  readonly discriminator = 1;
+  readonly kind = 'ManagementFeeBps';
 
   toJSON(): ManagementFeeBpsJSON {
     return {
-      kind: "ManagementFeeBps",
-    }
+      kind: 'ManagementFeeBps',
+    };
   }
 
   toEncodable() {
     return {
       ManagementFeeBps: {},
-    }
+    };
   }
 }
 
 export interface MinDepositAmountJSON {
-  kind: "MinDepositAmount"
+  kind: 'MinDepositAmount';
 }
 
 export class MinDepositAmount {
-  static readonly discriminator = 2
-  static readonly kind = "MinDepositAmount"
-  readonly discriminator = 2
-  readonly kind = "MinDepositAmount"
+  static readonly discriminator = 2;
+  static readonly kind = 'MinDepositAmount';
+  readonly discriminator = 2;
+  readonly kind = 'MinDepositAmount';
 
   toJSON(): MinDepositAmountJSON {
     return {
-      kind: "MinDepositAmount",
-    }
+      kind: 'MinDepositAmount',
+    };
   }
 
   toEncodable() {
     return {
       MinDepositAmount: {},
-    }
+    };
   }
 }
 
 export interface MinWithdrawAmountJSON {
-  kind: "MinWithdrawAmount"
+  kind: 'MinWithdrawAmount';
 }
 
 export class MinWithdrawAmount {
-  static readonly discriminator = 3
-  static readonly kind = "MinWithdrawAmount"
-  readonly discriminator = 3
-  readonly kind = "MinWithdrawAmount"
+  static readonly discriminator = 3;
+  static readonly kind = 'MinWithdrawAmount';
+  readonly discriminator = 3;
+  readonly kind = 'MinWithdrawAmount';
 
   toJSON(): MinWithdrawAmountJSON {
     return {
-      kind: "MinWithdrawAmount",
-    }
+      kind: 'MinWithdrawAmount',
+    };
   }
 
   toEncodable() {
     return {
       MinWithdrawAmount: {},
-    }
+    };
   }
 }
 
 export interface MintInvestAmountJSON {
-  kind: "MintInvestAmount"
+  kind: 'MintInvestAmount';
 }
 
 export class MintInvestAmount {
-  static readonly discriminator = 4
-  static readonly kind = "MintInvestAmount"
-  readonly discriminator = 4
-  readonly kind = "MintInvestAmount"
+  static readonly discriminator = 4;
+  static readonly kind = 'MintInvestAmount';
+  readonly discriminator = 4;
+  readonly kind = 'MintInvestAmount';
 
   toJSON(): MintInvestAmountJSON {
     return {
-      kind: "MintInvestAmount",
-    }
+      kind: 'MintInvestAmount',
+    };
   }
 
   toEncodable() {
     return {
       MintInvestAmount: {},
-    }
+    };
   }
 }
 
 export interface MinInvestDelaySlotsJSON {
-  kind: "MinInvestDelaySlots"
+  kind: 'MinInvestDelaySlots';
 }
 
 export class MinInvestDelaySlots {
-  static readonly discriminator = 5
-  static readonly kind = "MinInvestDelaySlots"
-  readonly discriminator = 5
-  readonly kind = "MinInvestDelaySlots"
+  static readonly discriminator = 5;
+  static readonly kind = 'MinInvestDelaySlots';
+  readonly discriminator = 5;
+  readonly kind = 'MinInvestDelaySlots';
 
   toJSON(): MinInvestDelaySlotsJSON {
     return {
-      kind: "MinInvestDelaySlots",
-    }
+      kind: 'MinInvestDelaySlots',
+    };
   }
 
   toEncodable() {
     return {
       MinInvestDelaySlots: {},
-    }
+    };
   }
 }
 
 export interface CrankFundFeePerReserveJSON {
-  kind: "CrankFundFeePerReserve"
+  kind: 'CrankFundFeePerReserve';
 }
 
 export class CrankFundFeePerReserve {
-  static readonly discriminator = 6
-  static readonly kind = "CrankFundFeePerReserve"
-  readonly discriminator = 6
-  readonly kind = "CrankFundFeePerReserve"
+  static readonly discriminator = 6;
+  static readonly kind = 'CrankFundFeePerReserve';
+  readonly discriminator = 6;
+  readonly kind = 'CrankFundFeePerReserve';
 
   toJSON(): CrankFundFeePerReserveJSON {
     return {
-      kind: "CrankFundFeePerReserve",
-    }
+      kind: 'CrankFundFeePerReserve',
+    };
   }
 
   toEncodable() {
     return {
       CrankFundFeePerReserve: {},
-    }
+    };
   }
 }
 
 export interface PendingVaultAdminJSON {
-  kind: "PendingVaultAdmin"
+  kind: 'PendingVaultAdmin';
 }
 
 export class PendingVaultAdmin {
-  static readonly discriminator = 7
-  static readonly kind = "PendingVaultAdmin"
-  readonly discriminator = 7
-  readonly kind = "PendingVaultAdmin"
+  static readonly discriminator = 7;
+  static readonly kind = 'PendingVaultAdmin';
+  readonly discriminator = 7;
+  readonly kind = 'PendingVaultAdmin';
 
   toJSON(): PendingVaultAdminJSON {
     return {
-      kind: "PendingVaultAdmin",
-    }
+      kind: 'PendingVaultAdmin',
+    };
   }
 
   toEncodable() {
     return {
       PendingVaultAdmin: {},
-    }
+    };
   }
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(obj: any): types.VaultConfigFieldKind {
-  if (typeof obj !== "object") {
-    throw new Error("Invalid enum object")
+  if (typeof obj !== 'object') {
+    throw new Error('Invalid enum object');
   }
 
-  if ("PerformanceFeeBps" in obj) {
-    return new PerformanceFeeBps()
+  console.log('');
+  if ('PerformanceFeeBps' in obj) {
+    return new PerformanceFeeBps();
   }
-  if ("ManagementFeeBps" in obj) {
-    return new ManagementFeeBps()
+  if ('ManagementFeeBps' in obj) {
+    return new ManagementFeeBps();
   }
-  if ("MinDepositAmount" in obj) {
-    return new MinDepositAmount()
+  if ('MinDepositAmount' in obj) {
+    return new MinDepositAmount();
   }
-  if ("MinWithdrawAmount" in obj) {
-    return new MinWithdrawAmount()
+  if ('MinWithdrawAmount' in obj) {
+    return new MinWithdrawAmount();
   }
-  if ("MintInvestAmount" in obj) {
-    return new MintInvestAmount()
+  if ('MintInvestAmount' in obj) {
+    return new MintInvestAmount();
   }
-  if ("MinInvestDelaySlots" in obj) {
-    return new MinInvestDelaySlots()
+  if ('MinInvestDelaySlots' in obj) {
+    return new MinInvestDelaySlots();
   }
-  if ("CrankFundFeePerReserve" in obj) {
-    return new CrankFundFeePerReserve()
+  if ('CrankFundFeePerReserve' in obj) {
+    return new CrankFundFeePerReserve();
   }
-  if ("PendingVaultAdmin" in obj) {
-    return new PendingVaultAdmin()
+  if ('PendingVaultAdmin' in obj) {
+    return new PendingVaultAdmin();
   }
 
-  throw new Error("Invalid enum object")
+  throw new Error('Invalid enum object');
 }
 
-export function fromJSON(
-  obj: types.VaultConfigFieldJSON
-): types.VaultConfigFieldKind {
+export function fromJSON(obj: types.VaultConfigFieldJSON): types.VaultConfigFieldKind {
   switch (obj.kind) {
-    case "PerformanceFeeBps": {
-      return new PerformanceFeeBps()
+    case 'PerformanceFeeBps': {
+      return new PerformanceFeeBps();
     }
-    case "ManagementFeeBps": {
-      return new ManagementFeeBps()
+    case 'ManagementFeeBps': {
+      return new ManagementFeeBps();
     }
-    case "MinDepositAmount": {
-      return new MinDepositAmount()
+    case 'MinDepositAmount': {
+      return new MinDepositAmount();
     }
-    case "MinWithdrawAmount": {
-      return new MinWithdrawAmount()
+    case 'MinWithdrawAmount': {
+      return new MinWithdrawAmount();
     }
-    case "MintInvestAmount": {
-      return new MintInvestAmount()
+    case 'MintInvestAmount': {
+      return new MintInvestAmount();
     }
-    case "MinInvestDelaySlots": {
-      return new MinInvestDelaySlots()
+    case 'MinInvestDelaySlots': {
+      return new MinInvestDelaySlots();
     }
-    case "CrankFundFeePerReserve": {
-      return new CrankFundFeePerReserve()
+    case 'CrankFundFeePerReserve': {
+      return new CrankFundFeePerReserve();
     }
-    case "PendingVaultAdmin": {
-      return new PendingVaultAdmin()
+    case 'PendingVaultAdmin': {
+      return new PendingVaultAdmin();
     }
   }
 }
 
 export function layout(property?: string) {
   const ret = borsh.rustEnum([
-    borsh.struct([], "PerformanceFeeBps"),
-    borsh.struct([], "ManagementFeeBps"),
-    borsh.struct([], "MinDepositAmount"),
-    borsh.struct([], "MinWithdrawAmount"),
-    borsh.struct([], "MintInvestAmount"),
-    borsh.struct([], "MinInvestDelaySlots"),
-    borsh.struct([], "CrankFundFeePerReserve"),
-    borsh.struct([], "PendingVaultAdmin"),
-  ])
+    borsh.struct([], 'PerformanceFeeBps'),
+    borsh.struct([], 'ManagementFeeBps'),
+    borsh.struct([], 'MinDepositAmount'),
+    borsh.struct([], 'MinWithdrawAmount'),
+    borsh.struct([], 'MintInvestAmount'),
+    borsh.struct([], 'MinInvestDelaySlots'),
+    borsh.struct([], 'CrankFundFeePerReserve'),
+    borsh.struct([], 'PendingVaultAdmin'),
+  ]);
   if (property !== undefined) {
-    return ret.replicate(property)
+    return ret.replicate(property);
   }
-  return ret
+  return ret;
 }

package/src/leverage/operations.ts

@@ -526,9 +526,7 @@ async function buildDepositWithLeverageIxns(
       ...fillWsolAtaIxns,
       ...[flashBorrowIxn],
       ...kaminoDepositAndBorrowAction.setupIxs,
-      ...[kaminoDepositAndBorrowAction.lendingIxs[0]],
-      ...kaminoDepositAndBorrowAction.inBetweenIxs,
-      ...[kaminoDepositAndBorrowAction.lendingIxs[1]],
+      ...KaminoAction.actionToLendingIxs(kaminoDepositAndBorrowAction),
       ...kaminoDepositAndBorrowAction.cleanupIxs,
       ...swapInstructions,
       ...[flashRepayIxn],
@@ -541,9 +539,7 @@ async function buildDepositWithLeverageIxns(
       ...[flashBorrowIxn],
       ...swapInstructions,
       ...kaminoDepositAndBorrowAction.setupIxs,
-      ...[kaminoDepositAndBorrowAction.lendingIxs[0]],
-      ...kaminoDepositAndBorrowAction.inBetweenIxs,
-      ...[kaminoDepositAndBorrowAction.lendingIxs[1]],
+      ...KaminoAction.actionToLendingIxs(kaminoDepositAndBorrowAction),
       ...kaminoDepositAndBorrowAction.cleanupIxs,
       ...[flashRepayIxn],
     ];
@@ -930,9 +926,7 @@ export async function buildWithdrawWithLeverageIxns(
     ...fillWsolAtaIxns,
     ...[flashBorrowIxn],
     ...repayAndWithdrawAction.setupIxs,
-    ...[repayAndWithdrawAction.lendingIxs[0]],
-    ...repayAndWithdrawAction.inBetweenIxs,
-    ...[repayAndWithdrawAction.lendingIxs[1]],
+    ...KaminoAction.actionToLendingIxs(repayAndWithdrawAction),
     ...repayAndWithdrawAction.cleanupIxs,
     ...swapInstructions,
     ...[flashRepayIxn],

package/src/referrals/instructions.ts

@@ -1,6 +1,6 @@
 import { PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction, Connection } from '@solana/web3.js';
 import { KaminoMarket } from '../classes';
-import { checkIfAccountExists, referrerStatePda, referrerTokenStatePda, shortUrlPda, userMetadataPda } from '../utils';
+import { PublicKeySet, referrerStatePda, referrerTokenStatePda, shortUrlPda, userMetadataPda } from '../utils';
 import {
   PROGRAM_ID,
   ReferrerState,
@@ -12,9 +12,11 @@ import {
 export const getInitAllReferrerTokenStateIxns = async ({
   referrer,
   kaminoMarket,
+  payer = referrer,
 }: {
   referrer: PublicKey;
   kaminoMarket: KaminoMarket;
+  payer?: PublicKey;
 }) => {
   if (referrer.equals(PublicKey.default)) {
     throw new Error('Referrer not set');
@@ -25,27 +27,32 @@ export const getInitAllReferrerTokenStateIxns = async ({
   const initReferrerTokenStateIxns: TransactionInstruction[] = [];
 
   const tokenStatesToCreate: [PublicKey, PublicKey][] = [];
-  for (const reserve of kaminoMarket.reserves.values()) {
-    const referrerTokenStateAddress = referrerTokenStatePda(referrer, reserve.address, kaminoMarket.programId)[0];
-
-    if (!(await checkIfAccountExists(kaminoMarket.getConnection(), referrerTokenStateAddress))) {
-      tokenStatesToCreate.push([referrerTokenStateAddress, reserve?.address]);
+  const reserves = kaminoMarket.getReserves();
+  const referrerTokenStates = reserves.map((reserve) => {
+    return referrerTokenStatePda(referrer, reserve.address, kaminoMarket.programId)[0];
+  });
+  const uniqueReferrerTokenStates = new PublicKeySet<PublicKey>(referrerTokenStates).toArray();
+  const accounts = await kaminoMarket.getConnection().getMultipleAccountsInfo(uniqueReferrerTokenStates);
+  for (let i = 0; i < uniqueReferrerTokenStates.length; i++) {
+    if (!accounts[i]) {
+      tokenStatesToCreate.push([uniqueReferrerTokenStates[i], reserves[i].address]);
     }
   }
 
   tokenStatesToCreate.forEach(([referrerTokenStateAddress, reserveAddress]) => {
     const initReferrerTokenStateIx = initReferrerTokenState(
       {
-        referrer: referrer,
+        referrer,
       },
       {
         lendingMarket: kaminoMarket.getAddress(),
-        payer: referrer,
+        payer,
         reserve: reserveAddress,
         referrerTokenState: referrerTokenStateAddress,
         rent: SYSVAR_RENT_PUBKEY,
         systemProgram: SystemProgram.programId,
-      }
+      },
+      kaminoMarket.programId
     );
 
     initReferrerTokenStateIxns.push(initReferrerTokenStateIx);

package/src/utils/ata.ts

@@ -98,11 +98,6 @@ export function createAtasIdempotent(
   return res;
 }
 
-export const checkIfAccountExists = async (connection: Connection, account: PublicKey): Promise<boolean> => {
-  const acc = await connection.getAccountInfo(account);
-  return acc !== null;
-};
-
 export function getDepositWsolIxns(owner: PublicKey, ata: PublicKey, amountLamports: Decimal) {
   const ixns: TransactionInstruction[] = [];
 
@@ -158,15 +153,14 @@ export async function getTokenAccountBalance(provider: AnchorProvider, tokenAcco
 export async function getTokenAccountBalanceDecimal(
   connection: Connection,
   mint: PublicKey,
-  owner: PublicKey
+  owner: PublicKey,
+  tokenProgram: PublicKey = TOKEN_PROGRAM_ID,
 ): Promise<Decimal> {
-  const tokenAta = getAssociatedTokenAddress(mint, owner);
-  const ataExists = await checkIfAccountExists(connection, tokenAta);
-
-  if (!ataExists) {
-    return new Decimal(0);
-  } else {
-    const tokenData = (await connection.getTokenAccountBalance(tokenAta)).value;
-    return new Decimal(tokenData.uiAmountString!);
+  const ata = getAssociatedTokenAddress(mint, owner, true, tokenProgram);
+  const accInfo = await connection.getAccountInfo(ata);
+  if (accInfo === null) {
+    return new Decimal('0');
   }
+  const { value } = await connection.getTokenAccountBalance(ata);
+  return new Decimal(value.uiAmountString!);
 }