@kamino-finance/klend-sdk 7.1.2 → 7.1.4-beta.0

package/src/@codegen/klend/accounts/PoolState.ts

@@ -0,0 +1,192 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Rpc,
+} from "@solana/kit"
+/* eslint-enable @typescript-eslint/no-unused-vars */
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { borshAddress } from "../utils" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface PoolStateFields {
+  admin: Address
+  pendingAdmin: Address
+  basePoolAuthority: Address
+  basePoolAuthorityBump: BN
+  unstakingSolMint: Address
+  wsolVault: Address
+  actionAuthority: Address
+  poolLookupTable: Address
+  sharesIssued: BN
+  wsolUnstaking: BN
+  wsolInVault: BN
+  padding: Array<BN>
+}
+
+export interface PoolStateJSON {
+  admin: string
+  pendingAdmin: string
+  basePoolAuthority: string
+  basePoolAuthorityBump: string
+  unstakingSolMint: string
+  wsolVault: string
+  actionAuthority: string
+  poolLookupTable: string
+  sharesIssued: string
+  wsolUnstaking: string
+  wsolInVault: string
+  padding: Array<string>
+}
+
+export class PoolState {
+  readonly admin: Address
+  readonly pendingAdmin: Address
+  readonly basePoolAuthority: Address
+  readonly basePoolAuthorityBump: BN
+  readonly unstakingSolMint: Address
+  readonly wsolVault: Address
+  readonly actionAuthority: Address
+  readonly poolLookupTable: Address
+  readonly sharesIssued: BN
+  readonly wsolUnstaking: BN
+  readonly wsolInVault: BN
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    247, 237, 227, 245, 215, 195, 222, 70,
+  ])
+
+  static readonly layout = borsh.struct<PoolState>([
+    borshAddress("admin"),
+    borshAddress("pendingAdmin"),
+    borshAddress("basePoolAuthority"),
+    borsh.u64("basePoolAuthorityBump"),
+    borshAddress("unstakingSolMint"),
+    borshAddress("wsolVault"),
+    borshAddress("actionAuthority"),
+    borshAddress("poolLookupTable"),
+    borsh.u64("sharesIssued"),
+    borsh.u64("wsolUnstaking"),
+    borsh.u64("wsolInVault"),
+    borsh.array(borsh.u128(), 256, "padding"),
+  ])
+
+  constructor(fields: PoolStateFields) {
+    this.admin = fields.admin
+    this.pendingAdmin = fields.pendingAdmin
+    this.basePoolAuthority = fields.basePoolAuthority
+    this.basePoolAuthorityBump = fields.basePoolAuthorityBump
+    this.unstakingSolMint = fields.unstakingSolMint
+    this.wsolVault = fields.wsolVault
+    this.actionAuthority = fields.actionAuthority
+    this.poolLookupTable = fields.poolLookupTable
+    this.sharesIssued = fields.sharesIssued
+    this.wsolUnstaking = fields.wsolUnstaking
+    this.wsolInVault = fields.wsolInVault
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: Address,
+    programId: Address = PROGRAM_ID
+  ): Promise<PoolState | null> {
+    const info = await fetchEncodedAccount(rpc, address)
+
+    if (!info.exists) {
+      return null
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `PoolStateFields account ${address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      )
+    }
+
+    return this.decode(Buffer.from(info.data))
+  }
+
+  static async fetchMultiple(
+    rpc: Rpc<GetMultipleAccountsApi>,
+    addresses: Address[],
+    programId: Address = PROGRAM_ID
+  ): Promise<Array<PoolState | null>> {
+    const infos = await fetchEncodedAccounts(rpc, addresses)
+
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `PoolStateFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        )
+      }
+
+      return this.decode(Buffer.from(info.data))
+    })
+  }
+
+  static decode(data: Buffer): PoolState {
+    if (!data.slice(0, 8).equals(PoolState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PoolState.layout.decode(data.slice(8))
+
+    return new PoolState({
+      admin: dec.admin,
+      pendingAdmin: dec.pendingAdmin,
+      basePoolAuthority: dec.basePoolAuthority,
+      basePoolAuthorityBump: dec.basePoolAuthorityBump,
+      unstakingSolMint: dec.unstakingSolMint,
+      wsolVault: dec.wsolVault,
+      actionAuthority: dec.actionAuthority,
+      poolLookupTable: dec.poolLookupTable,
+      sharesIssued: dec.sharesIssued,
+      wsolUnstaking: dec.wsolUnstaking,
+      wsolInVault: dec.wsolInVault,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): PoolStateJSON {
+    return {
+      admin: this.admin,
+      pendingAdmin: this.pendingAdmin,
+      basePoolAuthority: this.basePoolAuthority,
+      basePoolAuthorityBump: this.basePoolAuthorityBump.toString(),
+      unstakingSolMint: this.unstakingSolMint,
+      wsolVault: this.wsolVault,
+      actionAuthority: this.actionAuthority,
+      poolLookupTable: this.poolLookupTable,
+      sharesIssued: this.sharesIssued.toString(),
+      wsolUnstaking: this.wsolUnstaking.toString(),
+      wsolInVault: this.wsolInVault.toString(),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: PoolStateJSON): PoolState {
+    return new PoolState({
+      admin: address(obj.admin),
+      pendingAdmin: address(obj.pendingAdmin),
+      basePoolAuthority: address(obj.basePoolAuthority),
+      basePoolAuthorityBump: new BN(obj.basePoolAuthorityBump),
+      unstakingSolMint: address(obj.unstakingSolMint),
+      wsolVault: address(obj.wsolVault),
+      actionAuthority: address(obj.actionAuthority),
+      poolLookupTable: address(obj.poolLookupTable),
+      sharesIssued: new BN(obj.sharesIssued),
+      wsolUnstaking: new BN(obj.wsolUnstaking),
+      wsolInVault: new BN(obj.wsolInVault),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/@codegen/klend/accounts/Reserve.ts

@@ -39,6 +39,8 @@ export interface ReserveFields {
    * elevation group when this reserve is part of the collaterals.
    */
   borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  /** The tracker of ticket-based withdrawals. */
+  withdrawQueue: types.WithdrawQueueFields
   padding: Array<BN>
 }
 
@@ -66,6 +68,8 @@ export interface ReserveJSON {
    * elevation group when this reserve is part of the collaterals.
    */
   borrowedAmountsAgainstThisReserveInElevationGroups: Array<string>
+  /** The tracker of ticket-based withdrawals. */
+  withdrawQueue: types.WithdrawQueueJSON
   padding: Array<string>
 }
 
@@ -93,6 +97,8 @@ export class Reserve {
    * elevation group when this reserve is part of the collaterals.
    */
   readonly borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  /** The tracker of ticket-based withdrawals. */
+  readonly withdrawQueue: types.WithdrawQueue
   readonly padding: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -110,14 +116,15 @@ export class Reserve {
     types.ReserveCollateral.layout("collateral"),
     borsh.array(borsh.u64(), 150, "reserveCollateralPadding"),
     types.ReserveConfig.layout("config"),
-    borsh.array(borsh.u64(), 116, "configPadding"),
+    borsh.array(borsh.u64(), 113, "configPadding"),
     borsh.u64("borrowedAmountOutsideElevationGroup"),
     borsh.array(
       borsh.u64(),
       32,
       "borrowedAmountsAgainstThisReserveInElevationGroups"
     ),
-    borsh.array(borsh.u64(), 207, "padding"),
+    types.WithdrawQueue.layout("withdrawQueue"),
+    borsh.array(borsh.u64(), 204, "padding"),
   ])
 
   constructor(fields: ReserveFields) {
@@ -136,6 +143,7 @@ export class Reserve {
       fields.borrowedAmountOutsideElevationGroup
     this.borrowedAmountsAgainstThisReserveInElevationGroups =
       fields.borrowedAmountsAgainstThisReserveInElevationGroups
+    this.withdrawQueue = new types.WithdrawQueue({ ...fields.withdrawQueue })
     this.padding = fields.padding
   }
 
@@ -202,6 +210,7 @@ export class Reserve {
         dec.borrowedAmountOutsideElevationGroup,
       borrowedAmountsAgainstThisReserveInElevationGroups:
         dec.borrowedAmountsAgainstThisReserveInElevationGroups,
+      withdrawQueue: types.WithdrawQueue.fromDecoded(dec.withdrawQueue),
       padding: dec.padding,
     })
   }
@@ -229,6 +238,7 @@ export class Reserve {
         this.borrowedAmountsAgainstThisReserveInElevationGroups.map((item) =>
           item.toString()
         ),
+      withdrawQueue: this.withdrawQueue.toJSON(),
       padding: this.padding.map((item) => item.toString()),
     }
   }
@@ -257,6 +267,7 @@ export class Reserve {
         obj.borrowedAmountsAgainstThisReserveInElevationGroups.map(
           (item) => new BN(item)
         ),
+      withdrawQueue: types.WithdrawQueue.fromJSON(obj.withdrawQueue),
       padding: obj.padding.map((item) => new BN(item)),
     })
   }

package/src/@codegen/klend/accounts/UnstakeTicket.ts

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Rpc,
+} from "@solana/kit"
+/* eslint-enable @typescript-eslint/no-unused-vars */
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { borshAddress } from "../utils" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface UnstakeTicketFields {
+  authority: Address
+  poolState: Address
+  obligationMetadata: Address
+  initialUsol: BN
+  remainingUsol: BN
+  minimumEpochToBurn: BN
+  padding0: Array<BN>
+  padding: Array<BN>
+}
+
+export interface UnstakeTicketJSON {
+  authority: string
+  poolState: string
+  obligationMetadata: string
+  initialUsol: string
+  remainingUsol: string
+  minimumEpochToBurn: string
+  padding0: Array<string>
+  padding: Array<string>
+}
+
+export class UnstakeTicket {
+  readonly authority: Address
+  readonly poolState: Address
+  readonly obligationMetadata: Address
+  readonly initialUsol: BN
+  readonly remainingUsol: BN
+  readonly minimumEpochToBurn: BN
+  readonly padding0: Array<BN>
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    131, 84, 209, 38, 145, 157, 181, 127,
+  ])
+
+  static readonly layout = borsh.struct<UnstakeTicket>([
+    borshAddress("authority"),
+    borshAddress("poolState"),
+    borshAddress("obligationMetadata"),
+    borsh.u64("initialUsol"),
+    borsh.u64("remainingUsol"),
+    borsh.u64("minimumEpochToBurn"),
+    borsh.array(borsh.u64(), 1, "padding0"),
+    borsh.array(borsh.u128(), 16, "padding"),
+  ])
+
+  constructor(fields: UnstakeTicketFields) {
+    this.authority = fields.authority
+    this.poolState = fields.poolState
+    this.obligationMetadata = fields.obligationMetadata
+    this.initialUsol = fields.initialUsol
+    this.remainingUsol = fields.remainingUsol
+    this.minimumEpochToBurn = fields.minimumEpochToBurn
+    this.padding0 = fields.padding0
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: Address,
+    programId: Address = PROGRAM_ID
+  ): Promise<UnstakeTicket | null> {
+    const info = await fetchEncodedAccount(rpc, address)
+
+    if (!info.exists) {
+      return null
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `UnstakeTicketFields account ${address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      )
+    }
+
+    return this.decode(Buffer.from(info.data))
+  }
+
+  static async fetchMultiple(
+    rpc: Rpc<GetMultipleAccountsApi>,
+    addresses: Address[],
+    programId: Address = PROGRAM_ID
+  ): Promise<Array<UnstakeTicket | null>> {
+    const infos = await fetchEncodedAccounts(rpc, addresses)
+
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `UnstakeTicketFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        )
+      }
+
+      return this.decode(Buffer.from(info.data))
+    })
+  }
+
+  static decode(data: Buffer): UnstakeTicket {
+    if (!data.slice(0, 8).equals(UnstakeTicket.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = UnstakeTicket.layout.decode(data.slice(8))
+
+    return new UnstakeTicket({
+      authority: dec.authority,
+      poolState: dec.poolState,
+      obligationMetadata: dec.obligationMetadata,
+      initialUsol: dec.initialUsol,
+      remainingUsol: dec.remainingUsol,
+      minimumEpochToBurn: dec.minimumEpochToBurn,
+      padding0: dec.padding0,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): UnstakeTicketJSON {
+    return {
+      authority: this.authority,
+      poolState: this.poolState,
+      obligationMetadata: this.obligationMetadata,
+      initialUsol: this.initialUsol.toString(),
+      remainingUsol: this.remainingUsol.toString(),
+      minimumEpochToBurn: this.minimumEpochToBurn.toString(),
+      padding0: this.padding0.map((item) => item.toString()),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: UnstakeTicketJSON): UnstakeTicket {
+    return new UnstakeTicket({
+      authority: address(obj.authority),
+      poolState: address(obj.poolState),
+      obligationMetadata: address(obj.obligationMetadata),
+      initialUsol: new BN(obj.initialUsol),
+      remainingUsol: new BN(obj.remainingUsol),
+      minimumEpochToBurn: new BN(obj.minimumEpochToBurn),
+      padding0: obj.padding0.map((item) => new BN(item)),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/@codegen/klend/accounts/UserState.ts

@@ -19,42 +19,17 @@ export interface UserStateFields {
   userId: BN
   farmState: Address
   owner: Address
-  /** Indicate if this user state is part of a delegated farm */
   isFarmDelegated: number
   padding0: Array<number>
-  /**
-   * Rewards tally used for computation of gained rewards
-   * (scaled from `Decimal` representation).
-   */
   rewardsTallyScaled: Array<BN>
-  /** Number of reward tokens ready for claim */
   rewardsIssuedUnclaimed: Array<BN>
   lastClaimTs: Array<BN>
-  /**
-   * User stake deposited and usable, generating rewards and fees.
-   * (scaled from `Decimal` representation).
-   */
   activeStakeScaled: BN
-  /**
-   * User stake deposited but not usable and not generating rewards yet.
-   * (scaled from `Decimal` representation).
-   */
   pendingDepositStakeScaled: BN
-  /**
-   * After this timestamp, pending user stake can be moved to user stake
-   * Initialized to now() + delayed user stake period
-   */
   pendingDepositStakeTs: BN
-  /**
-   * User deposits unstaked, pending for withdrawal, not usable and not generating rewards.
-   * (scaled from `Decimal` representation).
-   */
   pendingWithdrawalUnstakeScaled: BN
-  /** After this timestamp, user can withdraw their deposit. */
   pendingWithdrawalUnstakeTs: BN
-  /** User bump used for account address validation */
   bump: BN
-  /** Delegatee used for initialisation - useful to check against */
   delegatee: Address
   lastStakeTs: BN
   padding1: Array<BN>
@@ -64,42 +39,17 @@ export interface UserStateJSON {
   userId: string
   farmState: string
   owner: string
-  /** Indicate if this user state is part of a delegated farm */
   isFarmDelegated: number
   padding0: Array<number>
-  /**
-   * Rewards tally used for computation of gained rewards
-   * (scaled from `Decimal` representation).
-   */
   rewardsTallyScaled: Array<string>
-  /** Number of reward tokens ready for claim */
   rewardsIssuedUnclaimed: Array<string>
   lastClaimTs: Array<string>
-  /**
-   * User stake deposited and usable, generating rewards and fees.
-   * (scaled from `Decimal` representation).
-   */
   activeStakeScaled: string
-  /**
-   * User stake deposited but not usable and not generating rewards yet.
-   * (scaled from `Decimal` representation).
-   */
   pendingDepositStakeScaled: string
-  /**
-   * After this timestamp, pending user stake can be moved to user stake
-   * Initialized to now() + delayed user stake period
-   */
   pendingDepositStakeTs: string
-  /**
-   * User deposits unstaked, pending for withdrawal, not usable and not generating rewards.
-   * (scaled from `Decimal` representation).
-   */
   pendingWithdrawalUnstakeScaled: string
-  /** After this timestamp, user can withdraw their deposit. */
   pendingWithdrawalUnstakeTs: string
-  /** User bump used for account address validation */
   bump: string
-  /** Delegatee used for initialisation - useful to check against */
   delegatee: string
   lastStakeTs: string
   padding1: Array<string>
@@ -109,42 +59,17 @@ export class UserState {
   readonly userId: BN
   readonly farmState: Address
   readonly owner: Address
-  /** Indicate if this user state is part of a delegated farm */
   readonly isFarmDelegated: number
   readonly padding0: Array<number>
-  /**
-   * Rewards tally used for computation of gained rewards
-   * (scaled from `Decimal` representation).
-   */
   readonly rewardsTallyScaled: Array<BN>
-  /** Number of reward tokens ready for claim */
   readonly rewardsIssuedUnclaimed: Array<BN>
   readonly lastClaimTs: Array<BN>
-  /**
-   * User stake deposited and usable, generating rewards and fees.
-   * (scaled from `Decimal` representation).
-   */
   readonly activeStakeScaled: BN
-  /**
-   * User stake deposited but not usable and not generating rewards yet.
-   * (scaled from `Decimal` representation).
-   */
   readonly pendingDepositStakeScaled: BN
-  /**
-   * After this timestamp, pending user stake can be moved to user stake
-   * Initialized to now() + delayed user stake period
-   */
   readonly pendingDepositStakeTs: BN
-  /**
-   * User deposits unstaked, pending for withdrawal, not usable and not generating rewards.
-   * (scaled from `Decimal` representation).
-   */
   readonly pendingWithdrawalUnstakeScaled: BN
-  /** After this timestamp, user can withdraw their deposit. */
   readonly pendingWithdrawalUnstakeTs: BN
-  /** User bump used for account address validation */
   readonly bump: BN
-  /** Delegatee used for initialisation - useful to check against */
   readonly delegatee: Address
   readonly lastStakeTs: BN
   readonly padding1: Array<BN>