@kamino-finance/klend-sdk 7.3.5-beta.0 → 7.3.6

package/src/classes/manager.ts

@@ -638,14 +638,31 @@ export class KaminoManager {
     value: string,
     signer?: TransactionSigner,
     lutIxsSigner?: TransactionSigner,
-    skipLutUpdate: boolean = false
+    skipLutUpdate: boolean = false,
+    errorOnOverride: boolean = true
   ): Promise<UpdateVaultConfigIxs> {
     if (typeof mode === 'string') {
       const field = VaultConfigField.fromDecoded({ [mode]: '' });
-      return this._vaultClient.updateVaultConfigIxs(vault, field, value, signer, lutIxsSigner, skipLutUpdate);
+      return this._vaultClient.updateVaultConfigIxs(
+        vault,
+        field,
+        value,
+        signer,
+        lutIxsSigner,
+        skipLutUpdate,
+        errorOnOverride
+      );
     }
 
-    return this._vaultClient.updateVaultConfigIxs(vault, mode, value, signer, lutIxsSigner, skipLutUpdate);
+    return this._vaultClient.updateVaultConfigIxs(
+      vault,
+      mode,
+      value,
+      signer,
+      lutIxsSigner,
+      skipLutUpdate,
+      errorOnOverride
+    );
   }
 
   /**

package/src/classes/reserve.ts

@@ -49,7 +49,7 @@ import {
   UpdateReserveConfigArgs,
 } from '../lib';
 import { aprToApy, KaminoPrices } from '@kamino-finance/kliquidity-sdk';
-import { FarmState, RewardInfo } from '@kamino-finance/farms-sdk';
+import { FarmAndKey, FarmState, RewardInfo } from '@kamino-finance/farms-sdk';
 import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import { maxBigInt } from '../utils/bigint';
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
@@ -70,7 +70,7 @@ export class KaminoReserve {
 
   tokenOraclePrice: TokenOracleData;
   stats: ReserveDataType;
-  private farmData: ReserveFarmInfo = { fetched: false, farmStates: [] };
+  private farmData: ReserveFarmInfo = { fetched: false, farms: [] };
 
   private rpc: Rpc<KaminoReserveRpcApi>;
   private readonly recentSlotDurationMs: number;
@@ -813,22 +813,22 @@ export class KaminoReserve {
 
   async loadFarmStates() {
     if (!this.farmData.fetched) {
-      const farmStates: FarmState[] = [];
+      const farmStates: FarmAndKey[] = [];
       const debtFarmAddress = this.getDebtFarmAddress();
       if (isSome(debtFarmAddress)) {
         const farmState = await FarmState.fetch(this.rpc, debtFarmAddress.value);
         if (farmState !== null) {
-          farmStates.push(farmState);
+          farmStates.push({ farmState, key: debtFarmAddress.value });
         }
       }
       const collateralFarmAddress = this.getCollateralFarmAddress();
       if (isSome(collateralFarmAddress)) {
         const farmState = await FarmState.fetch(this.rpc, collateralFarmAddress.value);
         if (farmState !== null) {
-          farmStates.push(farmState);
+          farmStates.push({ farmState, key: collateralFarmAddress.value });
         }
       }
-      this.farmData.farmStates = farmStates;
+      this.farmData.farms = farmStates;
       this.farmData.fetched = true;
     }
   }
@@ -839,14 +839,19 @@ export class KaminoReserve {
       throw Error('KaminoMarket must call loadReserves.');
     }
 
-    const isDebtReward = this.state.farmDebt === this.address;
     await this.loadFarmStates();
     const yields: ReserveRewardYield[] = [];
-    for (const farmState of this.farmData.farmStates) {
-      for (const rewardInfo of farmState.rewardInfos.filter(
+    for (const farmAndKey of this.farmData.farms) {
+      const isDebtReward = this.state.farmDebt === farmAndKey.key;
+      for (const rewardInfo of farmAndKey.farmState.rewardInfos.filter(
         (x) => x.token.mint !== DEFAULT_PUBLIC_KEY && !x.rewardsAvailable.isZero()
       )) {
-        const { apy, apr } = this.calculateRewardYield(prices, rewardInfo, isDebtReward);
+        const { apy, apr } = this.calculateRewardYield(
+          prices,
+          rewardInfo,
+          isDebtReward,
+          new Decimal(farmAndKey.farmState.totalActiveStakeScaled.toString())
+        );
         if (apy.isZero() && apr.isZero()) {
           continue;
         }
@@ -856,9 +861,14 @@ export class KaminoReserve {
     return yields;
   }
 
-  private calculateRewardYield(prices: KaminoPrices, rewardInfo: RewardInfo, isDebtReward: boolean) {
+  calculateRewardYield(
+    prices: KaminoPrices,
+    rewardInfo: RewardInfo,
+    isDebtReward: boolean,
+    farmTotalStakeLamports: Decimal
+  ) {
     const mintAddress = this.getLiquidityMint();
-    const rewardPerTimeUnitSecond = getRewardPerTimeUnitSecond(rewardInfo);
+    const rewardPerTimeUnitSecond = getRewardPerTimeUnitSecond(rewardInfo, farmTotalStakeLamports);
     const reserveToken = prices.spot[mintAddress.toString()];
     const rewardToken = prices.spot[rewardInfo.token.mint.toString()];
 

package/src/classes/shared.ts

@@ -1,6 +1,6 @@
 import { Address } from '@solana/kit';
 import Decimal from 'decimal.js';
-import { FarmState, RewardInfo } from '@kamino-finance/farms-sdk';
+import { FarmAndKey, RewardInfo } from '@kamino-finance/farms-sdk';
 
 export type ConfigType = Array<MarketConfigType>;
 
@@ -55,7 +55,7 @@ export type ReserveRewardYield = {
 
 export type ReserveFarmInfo = {
   fetched: boolean;
-  farmStates: FarmState[];
+  farms: FarmAndKey[];
 };
 
 export enum FeeCalculation {

package/src/classes/unstakingPool.ts

@@ -193,7 +193,7 @@ export class UnstakingPoolClient {
       data: Buffer.from([0]),
     };
 
-    if (isNaN(+value)) {
+    if (isNaN(+value) || value == DEFAULT_PUBLIC_KEY) {
       const data = address(value);
       args.data = Buffer.from(addressEncoder.encode(data));
     } else {

package/src/classes/vault.ts

@@ -816,7 +816,8 @@ export class KaminoVaultClient {
     value: string,
     adminAuthority?: TransactionSigner,
     lutIxsSigner?: TransactionSigner,
-    skipLutUpdate: boolean = false
+    skipLutUpdate: boolean = false,
+    errorOnOverride: boolean = true
   ): Promise<UpdateVaultConfigIxs> {
     const vaultState: VaultState = await vault.getState();
     const admin = parseVaultAdmin(vaultState, adminAuthority);
@@ -829,6 +830,14 @@ export class KaminoVaultClient {
       klendProgram: this._kaminoLendProgramId,
     };
 
+    if (mode.kind === new VaultConfigField.Farm().kind) {
+      if (value != DEFAULT_PUBLIC_KEY && vaultState.vaultFarm != DEFAULT_PUBLIC_KEY) {
+        if (errorOnOverride) {
+          throw new Error('Vault already has a farm, if you want to override it set errorOnOverride to false');
+        }
+      }
+    }
+
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
       entry: mode,
       data: this.getValueForModeAsBuffer(mode, value),
@@ -1876,7 +1885,7 @@ export class KaminoVaultClient {
     if (isWhitelistOnlyFlag) {
       const flag = parseBooleanFlag(value);
       return Buffer.from([flag]);
-    } else if (isNaN(+value)) {
+    } else if (isNaN(+value) || value == DEFAULT_PUBLIC_KEY) {
       if (mode.kind === new VaultConfigField.Name().kind) {
         const data = Array.from(this.encodeVaultName(value));
         return Buffer.from(data);

package/src/manager/client_kamino_manager.ts

@@ -569,66 +569,84 @@ async function main() {
       'Global admin signer (keypair path in execute/simulate modes, pubkey in multisig mode). Required when setting AllowInvestInWhitelistedReservesOnly or AllowAllocationsInWhitelistedReservesOnly to false'
     )
     .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
-    .action(async ({ vault, field, value, mode, staging, skipLutUpdate, lutSigner, globalAdmin, multisig }) => {
-      if (mode === 'multisig' && !multisig) {
-        throw new Error('If using multisig mode, multisig pubkey is required');
-      }
+    .option(
+      `--error-on-override`,
+      'If set, it will throw an error if the vault already has a farm, if you want to override it set errorOnOverride to false'
+    )
+    .action(
+      async ({
+        vault,
+        field,
+        value,
+        mode,
+        staging,
+        skipLutUpdate,
+        lutSigner,
+        globalAdmin,
+        multisig,
+        errorOnOverride,
+      }) => {
+        if (mode === 'multisig' && !multisig) {
+          throw new Error('If using multisig mode, multisig pubkey is required');
+        }
 
-      const ms = multisig ? address(multisig) : undefined;
-      const env = await initEnv(staging, ms);
-      const vaultAddress = address(vault);
+        const ms = multisig ? address(multisig) : undefined;
+        const env = await initEnv(staging, ms);
+        const vaultAddress = address(vault);
 
-      const kaminoManager = new KaminoManager(
-        env.c.rpc,
-        DEFAULT_RECENT_SLOT_DURATION_MS,
-        env.klendProgramId,
-        env.kvaultProgramId
-      );
-
-      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState();
+        const kaminoManager = new KaminoManager(
+          env.c.rpc,
+          DEFAULT_RECENT_SLOT_DURATION_MS,
+          env.klendProgramId,
+          env.kvaultProgramId
+        );
 
-      // Use global admin signer if provided, otherwise fall back to vault admin/noop signer depending on mode
-      let signer;
-      if (mode === 'multisig' && globalAdmin) {
-        signer = noopSigner(address(globalAdmin));
-      } else if (globalAdmin) {
-        signer = await parseKeypairFile(globalAdmin as string);
-      } else {
-        signer = await env.getSigner({ vaultState });
-      }
+        const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+        const vaultState = await kaminoVault.getState();
+
+        // Use global admin signer if provided, otherwise fall back to vault admin/noop signer depending on mode
+        let signer;
+        if (mode === 'multisig' && globalAdmin) {
+          signer = noopSigner(address(globalAdmin));
+        } else if (globalAdmin) {
+          signer = await parseKeypairFile(globalAdmin as string);
+        } else {
+          signer = await env.getSigner({ vaultState });
+        }
 
-      let lutSignerOrUndefined = undefined;
-      if (lutSigner) {
-        lutSignerOrUndefined = await parseKeypairFile(lutSigner as string);
-      }
+        let lutSignerOrUndefined = undefined;
+        if (lutSigner) {
+          lutSignerOrUndefined = await parseKeypairFile(lutSigner as string);
+        }
 
-      const shouldSkipLutUpdate = !!skipLutUpdate;
-      const instructions = await kaminoManager.updateVaultConfigIxs(
-        kaminoVault,
-        field,
-        value,
-        signer,
-        lutSignerOrUndefined,
-        shouldSkipLutUpdate
-      );
+        const shouldSkipLutUpdate = !!skipLutUpdate;
+        const instructions = await kaminoManager.updateVaultConfigIxs(
+          kaminoVault,
+          field,
+          value,
+          signer,
+          lutSignerOrUndefined,
+          shouldSkipLutUpdate,
+          errorOnOverride
+        );
 
-      await processTx(
-        env.c,
-        signer,
-        [
-          instructions.updateVaultConfigIx,
-          ...instructions.updateLUTIxs,
-          ...getPriorityFeeAndCuIxs({
-            priorityFeeMultiplier: 2500,
-          }),
-        ],
-        mode,
-        []
-      );
+        await processTx(
+          env.c,
+          signer,
+          [
+            instructions.updateVaultConfigIx,
+            ...instructions.updateLUTIxs,
+            ...getPriorityFeeAndCuIxs({
+              priorityFeeMultiplier: 2500,
+            }),
+          ],
+          mode,
+          []
+        );
 
-      mode === 'execute' && console.log('Vault updated');
-    });
+        mode === 'execute' && console.log('Vault updated');
+      }
+    );
 
   commands
     .command('add-update-whitelisted-reserve')

package/dist/chunk-5DIL2ZCI.js

@@ -1,373 +0,0 @@
-import { require_Layout } from './chunk-5RQOM3VO.js';
-import { __toESM } from './chunk-PR4QN5HX.js';
-import { getAddressCodec, address, fetchEncodedAccount, fetchEncodedAccounts } from '@solana/kit';
-import BN from 'bn.js';
-import * as borsh from '@coral-xyz/borsh';
-
-// src/@codegen/jupiter_perps/utils/borshAddress.ts
-var import_buffer_layout = __toESM(require_Layout(), 1);
-var addressCodec = getAddressCodec();
-function borshAddress(property) {
-  return new WrappedLayout(
-    (0, import_buffer_layout.blob)(32),
-    (b) => addressCodec.decode(b),
-    (addr) => Buffer.from(addressCodec.encode(addr)),
-    property
-  );
-}
-var WrappedLayout = class extends import_buffer_layout.Layout {
-  layout;
-  decoder;
-  encoder;
-  constructor(layout, decoder, encoder, property) {
-    super(layout.span, property);
-    this.layout = layout;
-    this.decoder = decoder;
-    this.encoder = encoder;
-  }
-  decode(b, offset) {
-    return this.decoder(this.layout.decode(b, offset));
-  }
-  encode(src, b, offset) {
-    return this.layout.encode(this.encoder(src), b, offset);
-  }
-  getSpan(b, offset) {
-    return this.layout.getSpan(b, offset);
-  }
-};
-var Fees = class _Fees {
-  increasePositionBps;
-  decreasePositionBps;
-  addRemoveLiquidityBps;
-  swapBps;
-  taxBps;
-  stableSwapBps;
-  stableSwapTaxBps;
-  liquidationRewardBps;
-  protocolShareBps;
-  constructor(fields) {
-    this.increasePositionBps = fields.increasePositionBps;
-    this.decreasePositionBps = fields.decreasePositionBps;
-    this.addRemoveLiquidityBps = fields.addRemoveLiquidityBps;
-    this.swapBps = fields.swapBps;
-    this.taxBps = fields.taxBps;
-    this.stableSwapBps = fields.stableSwapBps;
-    this.stableSwapTaxBps = fields.stableSwapTaxBps;
-    this.liquidationRewardBps = fields.liquidationRewardBps;
-    this.protocolShareBps = fields.protocolShareBps;
-  }
-  static layout(property) {
-    return borsh.struct(
-      [
-        borsh.u64("increasePositionBps"),
-        borsh.u64("decreasePositionBps"),
-        borsh.u64("addRemoveLiquidityBps"),
-        borsh.u64("swapBps"),
-        borsh.u64("taxBps"),
-        borsh.u64("stableSwapBps"),
-        borsh.u64("stableSwapTaxBps"),
-        borsh.u64("liquidationRewardBps"),
-        borsh.u64("protocolShareBps")
-      ],
-      property
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromDecoded(obj) {
-    return new _Fees({
-      increasePositionBps: obj.increasePositionBps,
-      decreasePositionBps: obj.decreasePositionBps,
-      addRemoveLiquidityBps: obj.addRemoveLiquidityBps,
-      swapBps: obj.swapBps,
-      taxBps: obj.taxBps,
-      stableSwapBps: obj.stableSwapBps,
-      stableSwapTaxBps: obj.stableSwapTaxBps,
-      liquidationRewardBps: obj.liquidationRewardBps,
-      protocolShareBps: obj.protocolShareBps
-    });
-  }
-  static toEncodable(fields) {
-    return {
-      increasePositionBps: fields.increasePositionBps,
-      decreasePositionBps: fields.decreasePositionBps,
-      addRemoveLiquidityBps: fields.addRemoveLiquidityBps,
-      swapBps: fields.swapBps,
-      taxBps: fields.taxBps,
-      stableSwapBps: fields.stableSwapBps,
-      stableSwapTaxBps: fields.stableSwapTaxBps,
-      liquidationRewardBps: fields.liquidationRewardBps,
-      protocolShareBps: fields.protocolShareBps
-    };
-  }
-  toJSON() {
-    return {
-      increasePositionBps: this.increasePositionBps.toString(),
-      decreasePositionBps: this.decreasePositionBps.toString(),
-      addRemoveLiquidityBps: this.addRemoveLiquidityBps.toString(),
-      swapBps: this.swapBps.toString(),
-      taxBps: this.taxBps.toString(),
-      stableSwapBps: this.stableSwapBps.toString(),
-      stableSwapTaxBps: this.stableSwapTaxBps.toString(),
-      liquidationRewardBps: this.liquidationRewardBps.toString(),
-      protocolShareBps: this.protocolShareBps.toString()
-    };
-  }
-  static fromJSON(obj) {
-    return new _Fees({
-      increasePositionBps: new BN(obj.increasePositionBps),
-      decreasePositionBps: new BN(obj.decreasePositionBps),
-      addRemoveLiquidityBps: new BN(obj.addRemoveLiquidityBps),
-      swapBps: new BN(obj.swapBps),
-      taxBps: new BN(obj.taxBps),
-      stableSwapBps: new BN(obj.stableSwapBps),
-      stableSwapTaxBps: new BN(obj.stableSwapTaxBps),
-      liquidationRewardBps: new BN(obj.liquidationRewardBps),
-      protocolShareBps: new BN(obj.protocolShareBps)
-    });
-  }
-  toEncodable() {
-    return _Fees.toEncodable(this);
-  }
-};
-var PoolApr = class _PoolApr {
-  lastUpdated;
-  feeAprBps;
-  realizedFeeUsd;
-  constructor(fields) {
-    this.lastUpdated = fields.lastUpdated;
-    this.feeAprBps = fields.feeAprBps;
-    this.realizedFeeUsd = fields.realizedFeeUsd;
-  }
-  static layout(property) {
-    return borsh.struct(
-      [
-        borsh.i64("lastUpdated"),
-        borsh.u64("feeAprBps"),
-        borsh.u64("realizedFeeUsd")
-      ],
-      property
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromDecoded(obj) {
-    return new _PoolApr({
-      lastUpdated: obj.lastUpdated,
-      feeAprBps: obj.feeAprBps,
-      realizedFeeUsd: obj.realizedFeeUsd
-    });
-  }
-  static toEncodable(fields) {
-    return {
-      lastUpdated: fields.lastUpdated,
-      feeAprBps: fields.feeAprBps,
-      realizedFeeUsd: fields.realizedFeeUsd
-    };
-  }
-  toJSON() {
-    return {
-      lastUpdated: this.lastUpdated.toString(),
-      feeAprBps: this.feeAprBps.toString(),
-      realizedFeeUsd: this.realizedFeeUsd.toString()
-    };
-  }
-  static fromJSON(obj) {
-    return new _PoolApr({
-      lastUpdated: new BN(obj.lastUpdated),
-      feeAprBps: new BN(obj.feeAprBps),
-      realizedFeeUsd: new BN(obj.realizedFeeUsd)
-    });
-  }
-  toEncodable() {
-    return _PoolApr.toEncodable(this);
-  }
-};
-var Limit = class _Limit {
-  maxAumUsd;
-  maxIndividualLpToken;
-  maxPositionUsd;
-  constructor(fields) {
-    this.maxAumUsd = fields.maxAumUsd;
-    this.maxIndividualLpToken = fields.maxIndividualLpToken;
-    this.maxPositionUsd = fields.maxPositionUsd;
-  }
-  static layout(property) {
-    return borsh.struct(
-      [
-        borsh.u128("maxAumUsd"),
-        borsh.u128("maxIndividualLpToken"),
-        borsh.u64("maxPositionUsd")
-      ],
-      property
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromDecoded(obj) {
-    return new _Limit({
-      maxAumUsd: obj.maxAumUsd,
-      maxIndividualLpToken: obj.maxIndividualLpToken,
-      maxPositionUsd: obj.maxPositionUsd
-    });
-  }
-  static toEncodable(fields) {
-    return {
-      maxAumUsd: fields.maxAumUsd,
-      maxIndividualLpToken: fields.maxIndividualLpToken,
-      maxPositionUsd: fields.maxPositionUsd
-    };
-  }
-  toJSON() {
-    return {
-      maxAumUsd: this.maxAumUsd.toString(),
-      maxIndividualLpToken: this.maxIndividualLpToken.toString(),
-      maxPositionUsd: this.maxPositionUsd.toString()
-    };
-  }
-  static fromJSON(obj) {
-    return new _Limit({
-      maxAumUsd: new BN(obj.maxAumUsd),
-      maxIndividualLpToken: new BN(obj.maxIndividualLpToken),
-      maxPositionUsd: new BN(obj.maxPositionUsd)
-    });
-  }
-  toEncodable() {
-    return _Limit.toEncodable(this);
-  }
-};
-var PROGRAM_ID_CLI = address(
-  "PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu"
-);
-var PROGRAM_ID = PROGRAM_ID_CLI;
-
-// src/@codegen/jupiter_perps/accounts/Pool.ts
-var Pool = class _Pool {
-  name;
-  custodies;
-  aumUsd;
-  limit;
-  fees;
-  poolApr;
-  maxRequestExecutionSec;
-  bump;
-  lpTokenBump;
-  inceptionTime;
-  static discriminator = Buffer.from([
-    241,
-    154,
-    109,
-    4,
-    17,
-    177,
-    109,
-    188
-  ]);
-  static layout = borsh.struct([
-    borsh.str("name"),
-    borsh.vec(borshAddress(), "custodies"),
-    borsh.u128("aumUsd"),
-    Limit.layout("limit"),
-    Fees.layout("fees"),
-    PoolApr.layout("poolApr"),
-    borsh.i64("maxRequestExecutionSec"),
-    borsh.u8("bump"),
-    borsh.u8("lpTokenBump"),
-    borsh.i64("inceptionTime")
-  ]);
-  constructor(fields) {
-    this.name = fields.name;
-    this.custodies = fields.custodies;
-    this.aumUsd = fields.aumUsd;
-    this.limit = new Limit({ ...fields.limit });
-    this.fees = new Fees({ ...fields.fees });
-    this.poolApr = new PoolApr({ ...fields.poolApr });
-    this.maxRequestExecutionSec = fields.maxRequestExecutionSec;
-    this.bump = fields.bump;
-    this.lpTokenBump = fields.lpTokenBump;
-    this.inceptionTime = fields.inceptionTime;
-  }
-  static async fetch(rpc, address3, programId = PROGRAM_ID) {
-    const info = await fetchEncodedAccount(rpc, address3);
-    if (!info.exists) {
-      return null;
-    }
-    if (info.programAddress !== programId) {
-      throw new Error(
-        `PoolFields account ${address3} belongs to wrong program ${info.programAddress}, expected ${programId}`
-      );
-    }
-    return this.decode(Buffer.from(info.data));
-  }
-  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID) {
-    const infos = await fetchEncodedAccounts(rpc, addresses);
-    return infos.map((info) => {
-      if (!info.exists) {
-        return null;
-      }
-      if (info.programAddress !== programId) {
-        throw new Error(
-          `PoolFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
-        );
-      }
-      return this.decode(Buffer.from(info.data));
-    });
-  }
-  static decode(data) {
-    if (!data.slice(0, 8).equals(_Pool.discriminator)) {
-      throw new Error("invalid account discriminator");
-    }
-    const dec = _Pool.layout.decode(data.slice(8));
-    return new _Pool({
-      name: dec.name,
-      custodies: dec.custodies,
-      aumUsd: dec.aumUsd,
-      limit: Limit.fromDecoded(dec.limit),
-      fees: Fees.fromDecoded(dec.fees),
-      poolApr: PoolApr.fromDecoded(dec.poolApr),
-      maxRequestExecutionSec: dec.maxRequestExecutionSec,
-      bump: dec.bump,
-      lpTokenBump: dec.lpTokenBump,
-      inceptionTime: dec.inceptionTime
-    });
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      custodies: this.custodies,
-      aumUsd: this.aumUsd.toString(),
-      limit: this.limit.toJSON(),
-      fees: this.fees.toJSON(),
-      poolApr: this.poolApr.toJSON(),
-      maxRequestExecutionSec: this.maxRequestExecutionSec.toString(),
-      bump: this.bump,
-      lpTokenBump: this.lpTokenBump,
-      inceptionTime: this.inceptionTime.toString()
-    };
-  }
-  static fromJSON(obj) {
-    return new _Pool({
-      name: obj.name,
-      custodies: obj.custodies.map((item) => address(item)),
-      aumUsd: new BN(obj.aumUsd),
-      limit: Limit.fromJSON(obj.limit),
-      fees: Fees.fromJSON(obj.fees),
-      poolApr: PoolApr.fromJSON(obj.poolApr),
-      maxRequestExecutionSec: new BN(obj.maxRequestExecutionSec),
-      bump: obj.bump,
-      lpTokenBump: obj.lpTokenBump,
-      inceptionTime: new BN(obj.inceptionTime)
-    });
-  }
-};
-
-// src/classes/jupiterPerps.ts
-async function getJLPApr(connection, poolAddress) {
-  const jlpPool = await Pool.fetch(connection, poolAddress);
-  if (!jlpPool) {
-    throw new Error("JLP pool not found");
-  }
-  const poolApr = jlpPool.poolApr;
-  return poolApr.feeAprBps.toNumber() / 100;
-}
-
-export { getJLPApr };
-//# sourceMappingURL=chunk-5DIL2ZCI.js.map
-//# sourceMappingURL=chunk-5DIL2ZCI.js.map