@kamino-finance/klend-sdk 5.10.33 → 5.10.35-beta.0

package/src/classes/manager.ts

@@ -76,6 +76,7 @@ import { getProgramAccounts } from '../utils/rpc';
 import { VaultConfigField, VaultConfigFieldKind } from '../idl_codegen_kamino_vault/types';
 import {
   AcceptVaultOwnershipIxs,
+  APYs,
   DepositIxs,
   InitVaultIxs,
   ReserveAllocationOverview,
@@ -186,6 +187,7 @@ export class KaminoManager {
     const createReserveInstructions = await createReserveIxs(
       this._connection,
       params.admin,
+      params.adminLiquiditySource,
       params.marketAddress,
       params.assetConfig.mint,
       reserveAccount.publicKey,
@@ -197,7 +199,7 @@ export class KaminoManager {
       reserveAccount.publicKey,
       params.assetConfig.getReserveConfig(),
       undefined,
-      true
+      false
     );
 
     const txnIxns: TransactionInstruction[][] = [];
@@ -778,14 +780,14 @@ export class KaminoManager {
    * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves as ratio; for percentage it needs multiplication by 100
    * @param vault - the kamino vault to get APY for
    * @param slot - current slot
-   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
-   * @returns APY for the vault
+   * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @returns a struct containing estimated gross APY and net APY (gross - vault fees) for the vault
    */
   async getVaultTheoreticalAPY(
     vault: VaultState,
     slot: number,
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
-  ): Promise<Decimal> {
+  ): Promise<APYs> {
     return this._vaultClient.getVaultTheoreticalAPY(vault, slot, vaultReserves);
   }
 
@@ -1266,6 +1268,17 @@ const updateLendingMarketConfig = (
         });
       }
       break;
+    case 'minInitialDepositAmount':
+      if (!market.minInitialDepositAmount.eq(newMarket.minInitialDepositAmount)) {
+        updateLendingMarketIxnsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator,
+            newMarket.minInitialDepositAmount.toNumber()
+          ),
+        });
+      }
+      break;
     default:
       assertNever(key);
   }
@@ -1330,6 +1343,7 @@ function updateMarketConfigEncodedValue(
     case UpdateLendingMarketMode.UpdateMinValueBfSkipPriorityLiqCheck.discriminator:
     case UpdateLendingMarketMode.UpdateMinValueLtvSkipPriorityLiqCheck.discriminator:
     case UpdateLendingMarketMode.UpdateIndividualAutodeleverageMarginCallPeriodSecs.discriminator:
+    case UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator:
       value = value as number;
       buffer.writeBigUint64LE(BigInt(value), 0);
       break;

package/src/classes/reserve.ts

@@ -1134,6 +1134,7 @@ const truncateBorrowCurve = (points: CurvePointFields[]): [number, number][] =>
 export async function createReserveIxs(
   connection: Connection,
   owner: PublicKey,
+  ownerLiquiditySource: PublicKey,
   lendingMarket: PublicKey,
   liquidityMint: PublicKey,
   reserveAddress: PublicKey,
@@ -1166,6 +1167,7 @@ export async function createReserveIxs(
     feeReceiver: feeVault,
     reserveCollateralMint: collateralMint,
     reserveCollateralSupply: collateralSupplyVault,
+    initialLiquiditySource: ownerLiquiditySource,
     liquidityTokenProgram: TOKEN_PROGRAM_ID,
     collateralTokenProgram: TOKEN_PROGRAM_ID,
     systemProgram: SystemProgram.programId,

package/src/classes/types.ts

@@ -54,3 +54,8 @@ export type ReserveAllocationOverview = {
   tokenAllocationCap: Decimal;
   ctokenAllocation: Decimal;
 };
+
+export type APYs = {
+  grossAPY: Decimal;
+  netAPY: Decimal;
+}

package/src/classes/utils.ts

@@ -1,8 +1,8 @@
 import { PubkeyHashMap, SLOTS_PER_SECOND, SLOTS_PER_YEAR } from '../utils';
 import Decimal from 'decimal.js';
 import { AccountInfo, PublicKey } from '@solana/web3.js';
-import { MarketOverview, ReserveOverview, SOL_MINTS } from '../lib';
-import { AccountLayout } from '@solana/spl-token';
+import { MarketOverview, ReserveOverview } from '../lib';
+import { AccountLayout, NATIVE_MINT } from '@solana/spl-token';
 import { ReserveAllocationOverview } from './types';
 import axios from 'axios';
 
@@ -188,7 +188,7 @@ export function lamportsToDecimal(amount: Decimal.Value, decimals: Decimal.Value
 }
 
 export const isSolMint = (mint: PublicKey): boolean => {
-  return SOL_MINTS.filter((m) => m.equals(mint)).length > 0;
+  return NATIVE_MINT.equals(mint);
 };
 
 export const valueOrZero = (value: Decimal): Decimal => {

package/src/classes/vault.ts

@@ -11,10 +11,10 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
-  getDepositWsolIxns,
+  getTransferWsolIxns,
   getTokenOracleData,
   KaminoMarket,
   KaminoReserve,
@@ -22,7 +22,6 @@ import {
   PubkeyHashMap,
   Reserve,
   UserState,
-  WRAPPED_SOL_MINT,
 } from '../lib';
 import {
   DepositAccounts,
@@ -70,6 +69,7 @@ import bs58 from 'bs58';
 import { getAccountOwner, getProgramAccounts } from '../utils/rpc';
 import {
   AcceptVaultOwnershipIxs,
+  APYs,
   DepositIxs,
   InitVaultIxs,
   ReserveAllocationOverview,
@@ -98,7 +98,7 @@ export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuY
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
 const BASE_VAULT_AUTHORITY_SEED = 'authority';
-const SHARES_SEEDS = 'shares';
+const SHARES_SEED = 'shares';
 
 /**
  * KaminoVaultClient is a class that provides a high-level interface to interact with the Kamino Vault program.
@@ -191,7 +191,7 @@ export class KaminoVaultClient {
     )[0];
 
     const sharesMint = PublicKey.findProgramAddressSync(
-      [Buffer.from(SHARES_SEEDS), vaultState.publicKey.toBytes()],
+      [Buffer.from(SHARES_SEED), vaultState.publicKey.toBytes()],
       this._kaminoVaultProgramId
     )[0];
 
@@ -694,20 +694,20 @@ export class KaminoVaultClient {
     const userTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, user, true, tokenProgramID);
     const createAtasIxns: TransactionInstruction[] = [];
     const closeAtasIxns: TransactionInstruction[] = [];
-    if (vaultState.tokenMint.equals(WRAPPED_SOL_MINT)) {
+    if (vaultState.tokenMint.equals(NATIVE_MINT)) {
       const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = createAtasIdempotent(user, [
         {
-          mint: WRAPPED_SOL_MINT,
+          mint: NATIVE_MINT,
           tokenProgram: TOKEN_PROGRAM_ID,
         },
       ]);
       createAtasIxns.push(createWsolAtaIxn);
-      const depositWsolIxn = getDepositWsolIxns(
+      const transferWsolIxns = getTransferWsolIxns(
         user,
         wsolAta,
         numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil()
       );
-      createAtasIxns.push(...depositWsolIxn);
+      createAtasIxns.push(...transferWsolIxns);
     }
 
     const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxns }] = createAtasIdempotent(user, [
@@ -1005,6 +1005,7 @@ export class KaminoVaultClient {
    */
   async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this.getConnection());
+    const minInvestAmount = vaultState.minInvestAmount;
     const allReserves = this.getVaultReserves(vaultState);
     if (allReserves.length === 0) {
       throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
@@ -1024,6 +1025,7 @@ export class KaminoVaultClient {
     const curentVaultAllocations = this.getVaultAllocations(vaultState);
 
     const reservesToDisinvestFrom: PublicKey[] = [];
+    const reservesToInvestInto: PublicKey[] = [];
 
     for (let index = 0; index < allReserves.length; index++) {
       const reservePubkey = allReserves[index];
@@ -1037,8 +1039,15 @@ export class KaminoVaultClient {
         vaultState.tokenMintDecimals.toNumber()
       );
 
-      if (computedAllocation.lt(reserveAllocationLiquidityAmount)) {
-        reservesToDisinvestFrom.push(reservePubkey);
+      const diffInReserveTokens = computedAllocation.sub(reserveAllocationLiquidityAmount);
+      const diffInReserveLamports = collToLamportsDecimal(diffInReserveTokens, vaultState.tokenMintDecimals.toNumber());
+      // if the diff for the reserve is smaller than the min invest amount, we do not need to invest or disinvest
+      if (diffInReserveLamports.abs().gte(new Decimal(minInvestAmount.toString()))) {
+        if (computedAllocation.lt(reserveAllocationLiquidityAmount)) {
+          reservesToDisinvestFrom.push(reservePubkey);
+        } else {
+          reservesToInvestInto.push(reservePubkey);
+        }
       }
     }
 
@@ -1062,24 +1071,22 @@ export class KaminoVaultClient {
       investIxnsPromises.push(investIxsPromise);
     }
 
-    for (const reserve of allReserves) {
-      if (!reservesToDisinvestFrom.includes(reserve)) {
-        const reserveState = allReservesStateMap.get(reserve);
-        if (reserveState === null) {
-          throw new Error(`Reserve ${reserve.toBase58()} not found`);
-        }
-        const investIxsPromise = this.investSingleReserveIxs(
-          payer,
-          vault,
-          {
-            address: reserve,
-            state: reserveState!.state,
-          },
-          allReservesStateMap,
-          false
-        );
-        investIxnsPromises.push(investIxsPromise);
+    for (const reserve of reservesToInvestInto) {
+      const reserveState = allReservesStateMap.get(reserve);
+      if (reserveState === null) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
       }
+      const investIxsPromise = this.investSingleReserveIxs(
+        payer,
+        vault,
+        {
+          address: reserve,
+          state: reserveState!.state,
+        },
+        allReservesStateMap,
+        false
+      );
+      investIxnsPromises.push(investIxsPromise);
     }
 
     let investIxns: TransactionInstruction[] = [];
@@ -1500,7 +1507,7 @@ export class KaminoVaultClient {
       const allocation = reservesAllocations.get(reserve);
       return allocation?.targetWeight.isZero();
     });
-    if (allReservesHaveWeight0 || allReservesPubkeys.length === 0) {
+    if (allReservesPubkeys.length === 0 || allReservesHaveWeight0) {
       const computedHoldings = new PubkeyHashMap<PublicKey, Decimal>();
       allReservesPubkeys.forEach((reserve) => {
         computedHoldings.set(reserve, new Decimal(0));
@@ -1528,7 +1535,6 @@ export class KaminoVaultClient {
         const reserveWithWeight = initialVaultAllocations.get(reserve);
         const targetAllocation = reserveWithWeight!.targetWeight.mul(totalLeftover).div(currentAllocationSum);
         const reserveCap = reserveWithWeight!.tokenAllocationCap;
-        // todo: check if both target and reserveCap
         const amountToInvest = Decimal.min(targetAllocation, reserveCap, totalLeftToInvest);
         totalLeftToInvest = totalLeftToInvest.sub(amountToInvest);
         if (amountToInvest.eq(reserveCap)) {
@@ -2224,7 +2230,7 @@ export class KaminoVaultClient {
     // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
     const [
       vaultHoldingsWithUSDValue,
-      vaultTheoreticalAPY,
+      vaultTheoreticalAPYs,
       totalInvestedAndBorrowed,
       vaultCollaterals,
       reservesOverview,
@@ -2240,7 +2246,7 @@ export class KaminoVaultClient {
       holdingsUSD: vaultHoldingsWithUSDValue,
       reservesOverview: reservesOverview,
       vaultCollaterals: vaultCollaterals,
-      theoreticalSupplyAPY: vaultTheoreticalAPY,
+      theoreticalSupplyAPY: vaultTheoreticalAPYs,
       totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
       utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
       totalSupplied: totalInvestedAndBorrowed.totalInvested,
@@ -2351,13 +2357,13 @@ export class KaminoVaultClient {
    * @param vault - the kamino vault to get APY for
    * @param slot - current slot
    * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
-   * @returns APY for the vault
+   * @returns a struct containing estimated gross APY and net APY (gross - vault fees) for the vault
    */
   async getVaultTheoreticalAPY(
     vault: VaultState,
     slot: number,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
-  ): Promise<Decimal> {
+  ): Promise<APYs> {
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
 
     let totalWeights = new Decimal(0);
@@ -2379,14 +2385,20 @@ export class KaminoVaultClient {
       totalWeights = totalWeights.add(weight);
     });
     if (totalWeights.isZero()) {
-      return new Decimal(0);
+      return {
+        grossAPY: new Decimal(0),
+        netAPY: new Decimal(0),
+      };
     }
 
     const grossAPY = totalAPY.div(totalWeights);
     const netAPY = grossAPY
       .mul(new Decimal(1).sub(new Decimal(vault.performanceFeeBps.toString()).div(FullBPSDecimal)))
       .mul(new Decimal(1).sub(new Decimal(vault.managementFeeBps.toString()).div(FullBPSDecimal)));
-    return netAPY;
+    return {
+      grossAPY,
+      netAPY,
+    };
   }
 
   /**
@@ -2655,7 +2667,7 @@ export type VaultOverview = {
   holdingsUSD: VaultHoldingsWithUSDValue;
   reservesOverview: PubkeyHashMap<PublicKey, ReserveOverview>;
   vaultCollaterals: PubkeyHashMap<PublicKey, MarketOverview>;
-  theoreticalSupplyAPY: Decimal;
+  theoreticalSupplyAPY: APYs;
   totalBorrowed: Decimal;
   totalSupplied: Decimal;
   utilizationRatio: Decimal;

package/src/client.ts

@@ -308,7 +308,8 @@ async function deposit(connection: Connection, wallet: Keypair, token: string, d
     depositAmount,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
-    new VanillaObligation(STAGING_LENDING_MARKET)
+    new VanillaObligation(STAGING_LENDING_MARKET),
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -328,7 +329,8 @@ async function withdraw(connection: Connection, wallet: Keypair, token: string,
     depositAmount,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
-    new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET))
+    new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -348,7 +350,8 @@ async function borrow(connection: Connection, wallet: Keypair, token: string, bo
     borrowAmount,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
-    new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET))
+    new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -369,6 +372,7 @@ async function repay(connection: Connection, wallet: Keypair, token: string, bor
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
+    true,
     await connection.getSlot()
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());

package/src/client_kamino_manager.ts

@@ -54,6 +54,7 @@ import {
 } from './idl_codegen_kamino_vault/types/VaultConfigField';
 import { getAccountOwner } from './utils/rpc';
 import { printHoldings } from './classes/types_utils';
+import { getAssociatedTokenAddressSync } from '@solana/spl-token';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -87,7 +88,7 @@ async function main() {
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
       });
 
-      const _createMarketSig = await processTxn(env.client, env.payer, createMarketIxns, mode, 2500, [marketKp]);
+      await processTxn(env.client, env.payer, createMarketIxns, mode, 2500, [marketKp]);
 
       mode === 'execute' && console.log('Market created:', marketKp.publicKey.toBase58());
     });
@@ -122,8 +123,14 @@ async function main() {
       const reserveConfig = parseReserveConfigFromFile(reserveConfigFromFile);
       const assetConfig = new AssetReserveConfigCli(tokenMint, tokenMintProgramId, reserveConfig);
 
+      const adminAta =
+        mode === 'multisig'
+          ? getAssociatedTokenAddressSync(tokenMint, multisigPk)
+          : getAssociatedTokenAddressSync(tokenMint, env.payer.publicKey);
+
       const { reserve, txnIxns } = await kaminoManager.addAssetToMarketIxs({
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
+        adminLiquiditySource: adminAta,
         marketAddress: marketAddress,
         assetConfig: assetConfig,
       });
@@ -260,7 +267,7 @@ async function main() {
         2500,
         [vaultKp]
       );
-      await sleep(5000);
+      await sleep(2000);
       const _populateLUTSig = await processTxn(env.client, env.payer, instructions.populateLUTIxs, mode, 2500, []);
 
       mode === 'execute' && console.log('Vault created:', vaultKp.publicKey.toBase58());
@@ -426,7 +433,7 @@ async function main() {
       // if we need to create the LUT we have to do that in a separate tx and wait a little bit after
       if (syncLUTIxs.setupLUTIfNeededIxs.length > 0) {
         const setupLUTSig = await processTxn(env.client, env.payer, syncLUTIxs.setupLUTIfNeededIxs, mode, 2500, []);
-        await sleep(5000);
+        await sleep(2000);
         mode === 'execute' && console.log('LUT created and set to the vault:', setupLUTSig);
       }
       // if there are accounts to be added to the LUT we have to do that in a separate tx