@exponent-labs/klend-idl 0.9.0

package/src/accounts/Reserve.ts

@@ -0,0 +1,218 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+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 * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface ReserveFields {
+  version: BN
+  lastUpdate: types.LastUpdateFields
+  lendingMarket: PublicKey
+  farmCollateral: PublicKey
+  farmDebt: PublicKey
+  liquidity: types.ReserveLiquidityFields
+  reserveLiquidityPadding: Array<BN>
+  collateral: types.ReserveCollateralFields
+  reserveCollateralPadding: Array<BN>
+  config: types.ReserveConfigFields
+  configPadding: Array<BN>
+  borrowedAmountOutsideElevationGroup: BN
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  padding: Array<BN>
+}
+
+export interface ReserveJSON {
+  version: string
+  lastUpdate: types.LastUpdateJSON
+  lendingMarket: string
+  farmCollateral: string
+  farmDebt: string
+  liquidity: types.ReserveLiquidityJSON
+  reserveLiquidityPadding: Array<string>
+  collateral: types.ReserveCollateralJSON
+  reserveCollateralPadding: Array<string>
+  config: types.ReserveConfigJSON
+  configPadding: Array<string>
+  borrowedAmountOutsideElevationGroup: string
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<string>
+  padding: Array<string>
+}
+
+export class Reserve {
+  readonly version: BN
+  readonly lastUpdate: types.LastUpdate
+  readonly lendingMarket: PublicKey
+  readonly farmCollateral: PublicKey
+  readonly farmDebt: PublicKey
+  readonly liquidity: types.ReserveLiquidity
+  readonly reserveLiquidityPadding: Array<BN>
+  readonly collateral: types.ReserveCollateral
+  readonly reserveCollateralPadding: Array<BN>
+  readonly config: types.ReserveConfig
+  readonly configPadding: Array<BN>
+  readonly borrowedAmountOutsideElevationGroup: BN
+  readonly borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    43, 242, 204, 202, 26, 247, 59, 127,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u64("version"),
+    types.LastUpdate.layout("lastUpdate"),
+    borsh.publicKey("lendingMarket"),
+    borsh.publicKey("farmCollateral"),
+    borsh.publicKey("farmDebt"),
+    types.ReserveLiquidity.layout("liquidity"),
+    borsh.array(borsh.u64(), 150, "reserveLiquidityPadding"),
+    types.ReserveCollateral.layout("collateral"),
+    borsh.array(borsh.u64(), 150, "reserveCollateralPadding"),
+    types.ReserveConfig.layout("config"),
+    borsh.array(borsh.u64(), 117, "configPadding"),
+    borsh.u64("borrowedAmountOutsideElevationGroup"),
+    borsh.array(
+      borsh.u64(),
+      32,
+      "borrowedAmountsAgainstThisReserveInElevationGroups"
+    ),
+    borsh.array(borsh.u64(), 207, "padding"),
+  ])
+
+  constructor(fields: ReserveFields) {
+    this.version = fields.version
+    this.lastUpdate = new types.LastUpdate({ ...fields.lastUpdate })
+    this.lendingMarket = fields.lendingMarket
+    this.farmCollateral = fields.farmCollateral
+    this.farmDebt = fields.farmDebt
+    this.liquidity = new types.ReserveLiquidity({ ...fields.liquidity })
+    this.reserveLiquidityPadding = fields.reserveLiquidityPadding
+    this.collateral = new types.ReserveCollateral({ ...fields.collateral })
+    this.reserveCollateralPadding = fields.reserveCollateralPadding
+    this.config = new types.ReserveConfig({ ...fields.config })
+    this.configPadding = fields.configPadding
+    this.borrowedAmountOutsideElevationGroup =
+      fields.borrowedAmountOutsideElevationGroup
+    this.borrowedAmountsAgainstThisReserveInElevationGroups =
+      fields.borrowedAmountsAgainstThisReserveInElevationGroups
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Reserve | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<Reserve | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): Reserve {
+    if (!data.slice(0, 8).equals(Reserve.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Reserve.layout.decode(data.slice(8))
+
+    return new Reserve({
+      version: dec.version,
+      lastUpdate: types.LastUpdate.fromDecoded(dec.lastUpdate),
+      lendingMarket: dec.lendingMarket,
+      farmCollateral: dec.farmCollateral,
+      farmDebt: dec.farmDebt,
+      liquidity: types.ReserveLiquidity.fromDecoded(dec.liquidity),
+      reserveLiquidityPadding: dec.reserveLiquidityPadding,
+      collateral: types.ReserveCollateral.fromDecoded(dec.collateral),
+      reserveCollateralPadding: dec.reserveCollateralPadding,
+      config: types.ReserveConfig.fromDecoded(dec.config),
+      configPadding: dec.configPadding,
+      borrowedAmountOutsideElevationGroup:
+        dec.borrowedAmountOutsideElevationGroup,
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        dec.borrowedAmountsAgainstThisReserveInElevationGroups,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): ReserveJSON {
+    return {
+      version: this.version.toString(),
+      lastUpdate: this.lastUpdate.toJSON(),
+      lendingMarket: this.lendingMarket.toString(),
+      farmCollateral: this.farmCollateral.toString(),
+      farmDebt: this.farmDebt.toString(),
+      liquidity: this.liquidity.toJSON(),
+      reserveLiquidityPadding: this.reserveLiquidityPadding.map((item) =>
+        item.toString()
+      ),
+      collateral: this.collateral.toJSON(),
+      reserveCollateralPadding: this.reserveCollateralPadding.map((item) =>
+        item.toString()
+      ),
+      config: this.config.toJSON(),
+      configPadding: this.configPadding.map((item) => item.toString()),
+      borrowedAmountOutsideElevationGroup:
+        this.borrowedAmountOutsideElevationGroup.toString(),
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        this.borrowedAmountsAgainstThisReserveInElevationGroups.map((item) =>
+          item.toString()
+        ),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ReserveJSON): Reserve {
+    return new Reserve({
+      version: new BN(obj.version),
+      lastUpdate: types.LastUpdate.fromJSON(obj.lastUpdate),
+      lendingMarket: new PublicKey(obj.lendingMarket),
+      farmCollateral: new PublicKey(obj.farmCollateral),
+      farmDebt: new PublicKey(obj.farmDebt),
+      liquidity: types.ReserveLiquidity.fromJSON(obj.liquidity),
+      reserveLiquidityPadding: obj.reserveLiquidityPadding.map(
+        (item) => new BN(item)
+      ),
+      collateral: types.ReserveCollateral.fromJSON(obj.collateral),
+      reserveCollateralPadding: obj.reserveCollateralPadding.map(
+        (item) => new BN(item)
+      ),
+      config: types.ReserveConfig.fromJSON(obj.config),
+      configPadding: obj.configPadding.map((item) => new BN(item)),
+      borrowedAmountOutsideElevationGroup: new BN(
+        obj.borrowedAmountOutsideElevationGroup
+      ),
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        obj.borrowedAmountsAgainstThisReserveInElevationGroups.map(
+          (item) => new BN(item)
+        ),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/accounts/ShortUrl.ts

@@ -0,0 +1,86 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface ShortUrlFields {
+  referrer: PublicKey
+  shortUrl: string
+}
+
+export interface ShortUrlJSON {
+  referrer: string
+  shortUrl: string
+}
+
+export class ShortUrl {
+  readonly referrer: PublicKey
+  readonly shortUrl: string
+
+  static readonly discriminator = Buffer.from([28, 89, 174, 25, 226, 124, 126, 212])
+
+  static readonly layout = borsh.struct([borsh.publicKey("referrer"), borsh.str("shortUrl")])
+
+  constructor(fields: ShortUrlFields) {
+    this.referrer = fields.referrer
+    this.shortUrl = fields.shortUrl
+  }
+
+  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<ShortUrl | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<Array<ShortUrl | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): ShortUrl {
+    if (!data.slice(0, 8).equals(ShortUrl.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ShortUrl.layout.decode(data.slice(8))
+
+    return new ShortUrl({
+      referrer: dec.referrer,
+      shortUrl: dec.shortUrl,
+    })
+  }
+
+  toJSON(): ShortUrlJSON {
+    return {
+      referrer: this.referrer.toString(),
+      shortUrl: this.shortUrl,
+    }
+  }
+
+  static fromJSON(obj: ShortUrlJSON): ShortUrl {
+    return new ShortUrl({
+      referrer: new PublicKey(obj.referrer),
+      shortUrl: obj.shortUrl,
+    })
+  }
+}

package/src/accounts/UserMetadata.ts

@@ -0,0 +1,126 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+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 { PROGRAM_ID } from "../programId"
+
+export interface UserMetadataFields {
+  referrer: PublicKey
+  bump: BN
+  userLookupTable: PublicKey
+  owner: PublicKey
+  padding1: Array<BN>
+  padding2: Array<BN>
+}
+
+export interface UserMetadataJSON {
+  referrer: string
+  bump: string
+  userLookupTable: string
+  owner: string
+  padding1: Array<string>
+  padding2: Array<string>
+}
+
+export class UserMetadata {
+  readonly referrer: PublicKey
+  readonly bump: BN
+  readonly userLookupTable: PublicKey
+  readonly owner: PublicKey
+  readonly padding1: Array<BN>
+  readonly padding2: Array<BN>
+
+  static readonly discriminator = Buffer.from([157, 214, 220, 235, 98, 135, 171, 28])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("referrer"),
+    borsh.u64("bump"),
+    borsh.publicKey("userLookupTable"),
+    borsh.publicKey("owner"),
+    borsh.array(borsh.u64(), 51, "padding1"),
+    borsh.array(borsh.u64(), 64, "padding2"),
+  ])
+
+  constructor(fields: UserMetadataFields) {
+    this.referrer = fields.referrer
+    this.bump = fields.bump
+    this.userLookupTable = fields.userLookupTable
+    this.owner = fields.owner
+    this.padding1 = fields.padding1
+    this.padding2 = fields.padding2
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<UserMetadata | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<Array<UserMetadata | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): UserMetadata {
+    if (!data.slice(0, 8).equals(UserMetadata.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = UserMetadata.layout.decode(data.slice(8))
+
+    return new UserMetadata({
+      referrer: dec.referrer,
+      bump: dec.bump,
+      userLookupTable: dec.userLookupTable,
+      owner: dec.owner,
+      padding1: dec.padding1,
+      padding2: dec.padding2,
+    })
+  }
+
+  toJSON(): UserMetadataJSON {
+    return {
+      referrer: this.referrer.toString(),
+      bump: this.bump.toString(),
+      userLookupTable: this.userLookupTable.toString(),
+      owner: this.owner.toString(),
+      padding1: this.padding1.map((item) => item.toString()),
+      padding2: this.padding2.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: UserMetadataJSON): UserMetadata {
+    return new UserMetadata({
+      referrer: new PublicKey(obj.referrer),
+      bump: new BN(obj.bump),
+      userLookupTable: new PublicKey(obj.userLookupTable),
+      owner: new PublicKey(obj.owner),
+      padding1: obj.padding1.map((item) => new BN(item)),
+      padding2: obj.padding2.map((item) => new BN(item)),
+    })
+  }
+}

package/src/accounts/UserState.ts

@@ -0,0 +1,210 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+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 { PROGRAM_ID } from "../programId"
+
+export interface UserStateFields {
+  userId: BN
+  farmState: PublicKey
+  owner: PublicKey
+  isFarmDelegated: number
+  padding0: Array<number>
+  rewardsTallyScaled: Array<BN>
+  rewardsIssuedUnclaimed: Array<BN>
+  lastClaimTs: Array<BN>
+  activeStakeScaled: BN
+  pendingDepositStakeScaled: BN
+  pendingDepositStakeTs: BN
+  pendingWithdrawalUnstakeScaled: BN
+  pendingWithdrawalUnstakeTs: BN
+  bump: BN
+  delegatee: PublicKey
+  lastStakeTs: BN
+  padding1: Array<BN>
+}
+
+export interface UserStateJSON {
+  userId: string
+  farmState: string
+  owner: string
+  isFarmDelegated: number
+  padding0: Array<number>
+  rewardsTallyScaled: Array<string>
+  rewardsIssuedUnclaimed: Array<string>
+  lastClaimTs: Array<string>
+  activeStakeScaled: string
+  pendingDepositStakeScaled: string
+  pendingDepositStakeTs: string
+  pendingWithdrawalUnstakeScaled: string
+  pendingWithdrawalUnstakeTs: string
+  bump: string
+  delegatee: string
+  lastStakeTs: string
+  padding1: Array<string>
+}
+
+export class UserState {
+  readonly userId: BN
+  readonly farmState: PublicKey
+  readonly owner: PublicKey
+  readonly isFarmDelegated: number
+  readonly padding0: Array<number>
+  readonly rewardsTallyScaled: Array<BN>
+  readonly rewardsIssuedUnclaimed: Array<BN>
+  readonly lastClaimTs: Array<BN>
+  readonly activeStakeScaled: BN
+  readonly pendingDepositStakeScaled: BN
+  readonly pendingDepositStakeTs: BN
+  readonly pendingWithdrawalUnstakeScaled: BN
+  readonly pendingWithdrawalUnstakeTs: BN
+  readonly bump: BN
+  readonly delegatee: PublicKey
+  readonly lastStakeTs: BN
+  readonly padding1: Array<BN>
+
+  static readonly discriminator = Buffer.from([72, 177, 85, 249, 76, 167, 186, 126])
+
+  static readonly layout = borsh.struct([
+    borsh.u64("userId"),
+    borsh.publicKey("farmState"),
+    borsh.publicKey("owner"),
+    borsh.u8("isFarmDelegated"),
+    borsh.array(borsh.u8(), 7, "padding0"),
+    borsh.array(borsh.u128(), 10, "rewardsTallyScaled"),
+    borsh.array(borsh.u64(), 10, "rewardsIssuedUnclaimed"),
+    borsh.array(borsh.u64(), 10, "lastClaimTs"),
+    borsh.u128("activeStakeScaled"),
+    borsh.u128("pendingDepositStakeScaled"),
+    borsh.u64("pendingDepositStakeTs"),
+    borsh.u128("pendingWithdrawalUnstakeScaled"),
+    borsh.u64("pendingWithdrawalUnstakeTs"),
+    borsh.u64("bump"),
+    borsh.publicKey("delegatee"),
+    borsh.u64("lastStakeTs"),
+    borsh.array(borsh.u64(), 50, "padding1"),
+  ])
+
+  constructor(fields: UserStateFields) {
+    this.userId = fields.userId
+    this.farmState = fields.farmState
+    this.owner = fields.owner
+    this.isFarmDelegated = fields.isFarmDelegated
+    this.padding0 = fields.padding0
+    this.rewardsTallyScaled = fields.rewardsTallyScaled
+    this.rewardsIssuedUnclaimed = fields.rewardsIssuedUnclaimed
+    this.lastClaimTs = fields.lastClaimTs
+    this.activeStakeScaled = fields.activeStakeScaled
+    this.pendingDepositStakeScaled = fields.pendingDepositStakeScaled
+    this.pendingDepositStakeTs = fields.pendingDepositStakeTs
+    this.pendingWithdrawalUnstakeScaled = fields.pendingWithdrawalUnstakeScaled
+    this.pendingWithdrawalUnstakeTs = fields.pendingWithdrawalUnstakeTs
+    this.bump = fields.bump
+    this.delegatee = fields.delegatee
+    this.lastStakeTs = fields.lastStakeTs
+    this.padding1 = fields.padding1
+  }
+
+  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<UserState | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<Array<UserState | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): UserState {
+    if (!data.slice(0, 8).equals(UserState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = UserState.layout.decode(data.slice(8))
+
+    return new UserState({
+      userId: dec.userId,
+      farmState: dec.farmState,
+      owner: dec.owner,
+      isFarmDelegated: dec.isFarmDelegated,
+      padding0: dec.padding0,
+      rewardsTallyScaled: dec.rewardsTallyScaled,
+      rewardsIssuedUnclaimed: dec.rewardsIssuedUnclaimed,
+      lastClaimTs: dec.lastClaimTs,
+      activeStakeScaled: dec.activeStakeScaled,
+      pendingDepositStakeScaled: dec.pendingDepositStakeScaled,
+      pendingDepositStakeTs: dec.pendingDepositStakeTs,
+      pendingWithdrawalUnstakeScaled: dec.pendingWithdrawalUnstakeScaled,
+      pendingWithdrawalUnstakeTs: dec.pendingWithdrawalUnstakeTs,
+      bump: dec.bump,
+      delegatee: dec.delegatee,
+      lastStakeTs: dec.lastStakeTs,
+      padding1: dec.padding1,
+    })
+  }
+
+  toJSON(): UserStateJSON {
+    return {
+      userId: this.userId.toString(),
+      farmState: this.farmState.toString(),
+      owner: this.owner.toString(),
+      isFarmDelegated: this.isFarmDelegated,
+      padding0: this.padding0,
+      rewardsTallyScaled: this.rewardsTallyScaled.map((item) => item.toString()),
+      rewardsIssuedUnclaimed: this.rewardsIssuedUnclaimed.map((item) => item.toString()),
+      lastClaimTs: this.lastClaimTs.map((item) => item.toString()),
+      activeStakeScaled: this.activeStakeScaled.toString(),
+      pendingDepositStakeScaled: this.pendingDepositStakeScaled.toString(),
+      pendingDepositStakeTs: this.pendingDepositStakeTs.toString(),
+      pendingWithdrawalUnstakeScaled: this.pendingWithdrawalUnstakeScaled.toString(),
+      pendingWithdrawalUnstakeTs: this.pendingWithdrawalUnstakeTs.toString(),
+      bump: this.bump.toString(),
+      delegatee: this.delegatee.toString(),
+      lastStakeTs: this.lastStakeTs.toString(),
+      padding1: this.padding1.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: UserStateJSON): UserState {
+    return new UserState({
+      userId: new BN(obj.userId),
+      farmState: new PublicKey(obj.farmState),
+      owner: new PublicKey(obj.owner),
+      isFarmDelegated: obj.isFarmDelegated,
+      padding0: obj.padding0,
+      rewardsTallyScaled: obj.rewardsTallyScaled.map((item) => new BN(item)),
+      rewardsIssuedUnclaimed: obj.rewardsIssuedUnclaimed.map((item) => new BN(item)),
+      lastClaimTs: obj.lastClaimTs.map((item) => new BN(item)),
+      activeStakeScaled: new BN(obj.activeStakeScaled),
+      pendingDepositStakeScaled: new BN(obj.pendingDepositStakeScaled),
+      pendingDepositStakeTs: new BN(obj.pendingDepositStakeTs),
+      pendingWithdrawalUnstakeScaled: new BN(obj.pendingWithdrawalUnstakeScaled),
+      pendingWithdrawalUnstakeTs: new BN(obj.pendingWithdrawalUnstakeTs),
+      bump: new BN(obj.bump),
+      delegatee: new PublicKey(obj.delegatee),
+      lastStakeTs: new BN(obj.lastStakeTs),
+      padding1: obj.padding1.map((item) => new BN(item)),
+    })
+  }
+}

package/src/accounts/index.ts

@@ -0,0 +1,19 @@
+export { UserState } from "./UserState"
+export type { UserStateFields, UserStateJSON } from "./UserState"
+export { LendingMarket } from "./LendingMarket"
+export type { LendingMarketFields, LendingMarketJSON } from "./LendingMarket"
+export { Obligation } from "./Obligation"
+export type { ObligationFields, ObligationJSON } from "./Obligation"
+export { ReferrerState } from "./ReferrerState"
+export type { ReferrerStateFields, ReferrerStateJSON } from "./ReferrerState"
+export { ReferrerTokenState } from "./ReferrerTokenState"
+export type {
+  ReferrerTokenStateFields,
+  ReferrerTokenStateJSON,
+} from "./ReferrerTokenState"
+export { ShortUrl } from "./ShortUrl"
+export type { ShortUrlFields, ShortUrlJSON } from "./ShortUrl"
+export { UserMetadata } from "./UserMetadata"
+export type { UserMetadataFields, UserMetadataJSON } from "./UserMetadata"
+export { Reserve } from "./Reserve"
+export type { ReserveFields, ReserveJSON } from "./Reserve"