@kamino-finance/klend-sdk 5.0.7 → 5.1.1

package/src/idl_codegen_kamino_vault/types/VaultConfigField.ts

@@ -1,269 +1,270 @@
-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")
   }
 
-  console.log('');
-  if ('PerformanceFeeBps' in obj) {
-    return new PerformanceFeeBps();
+  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/idl_codegen_kamino_vault/types/WithdrawalCaps.ts

@@ -1,46 +1,46 @@
-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 WithdrawalCapsFields {
-  configCapacity: BN;
-  currentTotal: BN;
-  lastIntervalStartTimestamp: BN;
-  configIntervalLengthSeconds: BN;
+  configCapacity: BN
+  currentTotal: BN
+  lastIntervalStartTimestamp: BN
+  configIntervalLengthSeconds: BN
 }
 
 export interface WithdrawalCapsJSON {
-  configCapacity: string;
-  currentTotal: string;
-  lastIntervalStartTimestamp: string;
-  configIntervalLengthSeconds: string;
+  configCapacity: string
+  currentTotal: string
+  lastIntervalStartTimestamp: string
+  configIntervalLengthSeconds: string
 }
 
 /** Reserve Withdrawal Caps State */
 export class WithdrawalCaps {
-  readonly configCapacity: BN;
-  readonly currentTotal: BN;
-  readonly lastIntervalStartTimestamp: BN;
-  readonly configIntervalLengthSeconds: BN;
+  readonly configCapacity: BN
+  readonly currentTotal: BN
+  readonly lastIntervalStartTimestamp: BN
+  readonly configIntervalLengthSeconds: BN
 
   constructor(fields: WithdrawalCapsFields) {
-    this.configCapacity = fields.configCapacity;
-    this.currentTotal = fields.currentTotal;
-    this.lastIntervalStartTimestamp = fields.lastIntervalStartTimestamp;
-    this.configIntervalLengthSeconds = fields.configIntervalLengthSeconds;
+    this.configCapacity = fields.configCapacity
+    this.currentTotal = fields.currentTotal
+    this.lastIntervalStartTimestamp = fields.lastIntervalStartTimestamp
+    this.configIntervalLengthSeconds = fields.configIntervalLengthSeconds
   }
 
   static layout(property?: string) {
     return borsh.struct(
       [
-        borsh.i64('configCapacity'),
-        borsh.i64('currentTotal'),
-        borsh.u64('lastIntervalStartTimestamp'),
-        borsh.u64('configIntervalLengthSeconds'),
+        borsh.i64("configCapacity"),
+        borsh.i64("currentTotal"),
+        borsh.u64("lastIntervalStartTimestamp"),
+        borsh.u64("configIntervalLengthSeconds"),
       ],
       property
-    );
+    )
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -50,7 +50,7 @@ export class WithdrawalCaps {
       currentTotal: obj.currentTotal,
       lastIntervalStartTimestamp: obj.lastIntervalStartTimestamp,
       configIntervalLengthSeconds: obj.configIntervalLengthSeconds,
-    });
+    })
   }
 
   static toEncodable(fields: WithdrawalCapsFields) {
@@ -59,7 +59,7 @@ export class WithdrawalCaps {
       currentTotal: fields.currentTotal,
       lastIntervalStartTimestamp: fields.lastIntervalStartTimestamp,
       configIntervalLengthSeconds: fields.configIntervalLengthSeconds,
-    };
+    }
   }
 
   toJSON(): WithdrawalCapsJSON {
@@ -68,7 +68,7 @@ export class WithdrawalCaps {
       currentTotal: this.currentTotal.toString(),
       lastIntervalStartTimestamp: this.lastIntervalStartTimestamp.toString(),
       configIntervalLengthSeconds: this.configIntervalLengthSeconds.toString(),
-    };
+    }
   }
 
   static fromJSON(obj: WithdrawalCapsJSON): WithdrawalCaps {
@@ -77,10 +77,10 @@ export class WithdrawalCaps {
       currentTotal: new BN(obj.currentTotal),
       lastIntervalStartTimestamp: new BN(obj.lastIntervalStartTimestamp),
       configIntervalLengthSeconds: new BN(obj.configIntervalLengthSeconds),
-    });
+    })
   }
 
   toEncodable() {
-    return WithdrawalCaps.toEncodable(this);
+    return WithdrawalCaps.toEncodable(this)
   }
 }

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!);
 }