@kamino-finance/klend-sdk 7.0.4 → 7.0.6

package/src/classes/fraction.ts

@@ -3,11 +3,31 @@ import Decimal from 'decimal.js';
 import { roundNearest } from './utils';
 import { BigFractionBytes } from '../lib';
 
+/**
+ * The higher-precision {@link Decimal} counterpart that *must* be used by all operations within {@link Fraction}.
+ *
+ * ## How to use it?
+ * Simply do `new FractionDecimal(x)` instead of `new Decimal(x)`.
+ *
+ * ## Why is this needed?
+ * The default {@link Decimal.precision} is 20.
+ * Some fractions on which we operate (most notably: the {@link Fraction.MAX_F_BN}) have more than 20 significant
+ * digits, and at the same time they must encode to exact representation (e.g. because the smart contract expects an
+ * exact `0xffff...ff` which has a speciyaal meaning, like "withdraw *all*").
+ *
+ * ## Why was this *not* needed before?
+ * Some vibe-coded libraries that we use (e.g. `@orca-so/whirlpool-sdk`) statically initialize the global
+ * `Decimal.set({ precision: ... })` when loaded. A previous, fortunate import order allowed our {@link Fraction}'s
+ * constants to be computed using a sufficiently-high precision. This of course was broken by a random, unrelated
+ * refactor, and from that point on we decided to not rely on the thoughtful Orca developers.
+ */
+const FractionDecimal = Decimal.clone({ precision: 40 });
+
 export class Fraction {
   static MAX_SIZE_F = 128;
   static MAX_SIZE_BF = 256;
   static FRACTIONS = 60;
-  static MULTIPLIER = new Decimal(2).pow(Fraction.FRACTIONS);
+  static MULTIPLIER = new FractionDecimal(2).pow(Fraction.FRACTIONS);
 
   static MAX_F_BN = new BN(2).pow(new BN(Fraction.MAX_SIZE_F)).sub(new BN(1));
   static MAX_BF_BN = new BN(2).pow(new BN(Fraction.MAX_SIZE_BF)).sub(new BN(1));
@@ -24,11 +44,11 @@ export class Fraction {
   }
 
   toDecimal(): Decimal {
-    return new Decimal(this.valueSf.toString()).div(Fraction.MULTIPLIER);
+    return new FractionDecimal(this.valueSf.toString()).div(Fraction.MULTIPLIER);
   }
 
   static fromDecimal(n: Decimal | number): Fraction {
-    const scaledDecimal = new Decimal(n).mul(Fraction.MULTIPLIER);
+    const scaledDecimal = new FractionDecimal(n).mul(Fraction.MULTIPLIER);
     const roundedScaledDecimal = roundNearest(scaledDecimal);
     // Note: the `Decimal.toString()` can return exponential notation (e.g. "1e9") for large numbers. This notation is
     // not accepted by `BN` constructor (i.e. invalid character "e"). Hence, we use `Decimal.toFixed()` (which is
@@ -38,12 +58,12 @@ export class Fraction {
   }
 
   static fromBps(n: Decimal | number): Fraction {
-    const decimal = new Decimal(n).div(10000);
+    const decimal = new FractionDecimal(n).div(10000);
     return Fraction.fromDecimal(decimal);
   }
 
   static fromPercent(n: Decimal | number): Fraction {
-    const decimal = new Decimal(n).div(100);
+    const decimal = new FractionDecimal(n).div(100);
     return Fraction.fromDecimal(decimal);
   }
 

package/src/classes/manager.ts

@@ -1030,6 +1030,7 @@ export class KaminoManager {
    * @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
    * @param [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
+   * @param [tokensPrices] - a hashmap from a token pubkey to the price of the token in USD. Optional. If some tokens are not in the map, the function will fetch the price
    * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD, along sie APYs
    */
   async getVaultOverview(
@@ -1038,9 +1039,10 @@ export class KaminoManager {
     slot?: Slot,
     vaultReserves?: Map<Address, KaminoReserve>,
     kaminoMarkets?: KaminoMarket[],
-    currentSlot?: Slot
+    currentSlot?: Slot,
+    tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultOverview> {
-    return this._vaultClient.getVaultOverview(vault, price, slot, vaultReserves, kaminoMarkets, currentSlot);
+    return this._vaultClient.getVaultOverview(vault, price, slot, vaultReserves, kaminoMarkets, currentSlot, tokensPrices);
   }
 
   /**

package/src/classes/vault.ts

@@ -2657,6 +2657,7 @@ export class KaminoVaultClient {
    * @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
    * @param [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
+   * @param [tokensPrices] - a hashmap from a token pubkey to the price of the token in USD. Optional. If some tokens are not in the map, the function will fetch the price
    * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD, along sie APYs
    */
   async getVaultOverview(
@@ -2665,7 +2666,8 @@ export class KaminoVaultClient {
     slot?: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
     kaminoMarkets?: KaminoMarket[],
-    currentSlot?: Slot
+    currentSlot?: Slot,
+    tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultOverview> {
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
 
@@ -2689,13 +2691,20 @@ export class KaminoVaultClient {
     );
     const vaultCollateralsPromise = this.getVaultCollaterals(vault, slotForOverview, vaultReservesState, kaminoMarkets);
     const reservesOverviewPromise = this.getVaultReservesDetails(vault, slotForOverview, vaultReservesState);
-    const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(vault, vaultTokenPrice, farmsClient, slotForOverview);
+    const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(
+      vault,
+      vaultTokenPrice,
+      farmsClient,
+      slotForOverview,
+      tokensPrices
+    );
     const vaultReservesFarmIncentivesPromise = this.getVaultReservesFarmsIncentives(
       vault,
       vaultTokenPrice,
       farmsClient,
       slotForOverview,
-      vaultReservesState
+      vaultReservesState,
+      tokensPrices
     );
 
     // 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
@@ -3053,7 +3062,8 @@ export class KaminoVaultClient {
     vaultOrState: KaminoVault | VaultState,
     vaultTokenPrice: Decimal,
     farmsClient?: Farms,
-    slot?: Slot
+    slot?: Slot,
+    tokensPrices?: Map<Address, Decimal>
   ): Promise<FarmIncentives> {
     // Determine if we have a KaminoVault or VaultState
     const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
@@ -3069,7 +3079,7 @@ export class KaminoVaultClient {
     const stakedTokenMintDecimals = vaultState.sharesMintDecimals.toNumber();
 
     const kFarmsClient = farmsClient ? farmsClient : new Farms(this.getConnection());
-    return getFarmIncentives(kFarmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals);
+    return getFarmIncentives(kFarmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals, tokensPrices);
   }
 
   async getVaultReservesFarmsIncentives(
@@ -3077,7 +3087,8 @@ export class KaminoVaultClient {
     vaultTokenPrice: Decimal,
     farmsClient?: Farms,
     slot?: Slot,
-    vaultReservesMap?: Map<Address, KaminoReserve>
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultReservesFarmsIncentives> {
     const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
 
@@ -3117,7 +3128,9 @@ export class KaminoVaultClient {
         this._kaminoLendProgramId,
         kFarmsClient,
         currentSlot,
-        reserveState.state
+        reserveState.state,
+        undefined,
+        tokensPrices
       );
       vaultReservesFarmsIncentives.set(reserveAddress, reserveFarmIncentives.collateralFarmIncentives);
 

package/src/utils/farmUtils.ts

@@ -21,7 +21,8 @@ export async function getReserveFarmRewardsAPY(
   farmsClient: Farms,
   slot: Slot,
   reserveState?: Reserve,
-  cTokenMintDecimals?: number
+  cTokenMintDecimals?: number,
+  tokensPrices?: Map<Address, Decimal>
 ): Promise<ReserveIncentives> {
   const reserveIncentives: ReserveIncentives = {
     collateralFarmIncentives: {
@@ -54,7 +55,8 @@ export async function getReserveFarmRewardsAPY(
       farmsClient,
       farmCollateral,
       reserveCtokenPrice,
-      cTokenDecimals
+      cTokenDecimals,
+      tokensPrices
     );
     reserveIncentives.collateralFarmIncentives = farmIncentivesCollateral;
   }
@@ -64,7 +66,8 @@ export async function getReserveFarmRewardsAPY(
       farmsClient,
       farmDebt,
       reserveLiquidityTokenPrice,
-      stakedTokenMintDecimals
+      stakedTokenMintDecimals,
+      tokensPrices
     );
     reserveIncentives.debtFarmIncentives = farmIncentivesDebt;
   }