@exponent-labs/klend-idl 0.9.0

package/src/accounts/Obligation.ts

@@ -0,0 +1,282 @@
+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 ObligationFields {
+  tag: BN
+  lastUpdate: types.LastUpdateFields
+  lendingMarket: PublicKey
+  owner: PublicKey
+  deposits: Array<types.ObligationCollateralFields>
+  lowestReserveDepositLiquidationLtv: BN
+  depositedValueSf: BN
+  borrows: Array<types.ObligationLiquidityFields>
+  borrowFactorAdjustedDebtValueSf: BN
+  borrowedAssetsMarketValueSf: BN
+  allowedBorrowValueSf: BN
+  unhealthyBorrowValueSf: BN
+  depositsAssetTiers: Array<number>
+  borrowsAssetTiers: Array<number>
+  elevationGroup: number
+  numOfObsoleteReserves: number
+  hasDebt: number
+  referrer: PublicKey
+  borrowingDisabled: number
+  reserved: Array<number>
+  highestBorrowFactorPct: BN
+  padding3: Array<BN>
+}
+
+export interface ObligationJSON {
+  tag: string
+  lastUpdate: types.LastUpdateJSON
+  lendingMarket: string
+  owner: string
+  deposits: Array<types.ObligationCollateralJSON>
+  lowestReserveDepositLiquidationLtv: string
+  depositedValueSf: string
+  borrows: Array<types.ObligationLiquidityJSON>
+  borrowFactorAdjustedDebtValueSf: string
+  borrowedAssetsMarketValueSf: string
+  allowedBorrowValueSf: string
+  unhealthyBorrowValueSf: string
+  depositsAssetTiers: Array<number>
+  borrowsAssetTiers: Array<number>
+  elevationGroup: number
+  numOfObsoleteReserves: number
+  hasDebt: number
+  referrer: string
+  borrowingDisabled: number
+  reserved: Array<number>
+  highestBorrowFactorPct: string
+  padding3: Array<string>
+}
+
+export class Obligation {
+  readonly tag: BN
+  readonly lastUpdate: types.LastUpdate
+  readonly lendingMarket: PublicKey
+  readonly owner: PublicKey
+  readonly deposits: Array<types.ObligationCollateral>
+  readonly lowestReserveDepositLiquidationLtv: BN
+  readonly depositedValueSf: BN
+  readonly borrows: Array<types.ObligationLiquidity>
+  readonly borrowFactorAdjustedDebtValueSf: BN
+  readonly borrowedAssetsMarketValueSf: BN
+  readonly allowedBorrowValueSf: BN
+  readonly unhealthyBorrowValueSf: BN
+  readonly depositsAssetTiers: Array<number>
+  readonly borrowsAssetTiers: Array<number>
+  readonly elevationGroup: number
+  readonly numOfObsoleteReserves: number
+  readonly hasDebt: number
+  readonly referrer: PublicKey
+  readonly borrowingDisabled: number
+  readonly reserved: Array<number>
+  readonly highestBorrowFactorPct: BN
+  readonly padding3: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    168, 206, 141, 106, 88, 76, 172, 167,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u64("tag"),
+    types.LastUpdate.layout("lastUpdate"),
+    borsh.publicKey("lendingMarket"),
+    borsh.publicKey("owner"),
+    borsh.array(types.ObligationCollateral.layout(), 8, "deposits"),
+    borsh.u64("lowestReserveDepositLiquidationLtv"),
+    borsh.u128("depositedValueSf"),
+    borsh.array(types.ObligationLiquidity.layout(), 5, "borrows"),
+    borsh.u128("borrowFactorAdjustedDebtValueSf"),
+    borsh.u128("borrowedAssetsMarketValueSf"),
+    borsh.u128("allowedBorrowValueSf"),
+    borsh.u128("unhealthyBorrowValueSf"),
+    borsh.array(borsh.u8(), 8, "depositsAssetTiers"),
+    borsh.array(borsh.u8(), 5, "borrowsAssetTiers"),
+    borsh.u8("elevationGroup"),
+    borsh.u8("numOfObsoleteReserves"),
+    borsh.u8("hasDebt"),
+    borsh.publicKey("referrer"),
+    borsh.u8("borrowingDisabled"),
+    borsh.array(borsh.u8(), 7, "reserved"),
+    borsh.u64("highestBorrowFactorPct"),
+    borsh.array(borsh.u64(), 126, "padding3"),
+  ])
+
+  constructor(fields: ObligationFields) {
+    this.tag = fields.tag
+    this.lastUpdate = new types.LastUpdate({ ...fields.lastUpdate })
+    this.lendingMarket = fields.lendingMarket
+    this.owner = fields.owner
+    this.deposits = fields.deposits.map(
+      (item) => new types.ObligationCollateral({ ...item })
+    )
+    this.lowestReserveDepositLiquidationLtv =
+      fields.lowestReserveDepositLiquidationLtv
+    this.depositedValueSf = fields.depositedValueSf
+    this.borrows = fields.borrows.map(
+      (item) => new types.ObligationLiquidity({ ...item })
+    )
+    this.borrowFactorAdjustedDebtValueSf =
+      fields.borrowFactorAdjustedDebtValueSf
+    this.borrowedAssetsMarketValueSf = fields.borrowedAssetsMarketValueSf
+    this.allowedBorrowValueSf = fields.allowedBorrowValueSf
+    this.unhealthyBorrowValueSf = fields.unhealthyBorrowValueSf
+    this.depositsAssetTiers = fields.depositsAssetTiers
+    this.borrowsAssetTiers = fields.borrowsAssetTiers
+    this.elevationGroup = fields.elevationGroup
+    this.numOfObsoleteReserves = fields.numOfObsoleteReserves
+    this.hasDebt = fields.hasDebt
+    this.referrer = fields.referrer
+    this.borrowingDisabled = fields.borrowingDisabled
+    this.reserved = fields.reserved
+    this.highestBorrowFactorPct = fields.highestBorrowFactorPct
+    this.padding3 = fields.padding3
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Obligation | 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<Obligation | 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): Obligation {
+    if (!data.slice(0, 8).equals(Obligation.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Obligation.layout.decode(data.slice(8))
+
+    return new Obligation({
+      tag: dec.tag,
+      lastUpdate: types.LastUpdate.fromDecoded(dec.lastUpdate),
+      lendingMarket: dec.lendingMarket,
+      owner: dec.owner,
+      deposits: dec.deposits.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.ObligationCollateral.fromDecoded(item)
+      ),
+      lowestReserveDepositLiquidationLtv:
+        dec.lowestReserveDepositLiquidationLtv,
+      depositedValueSf: dec.depositedValueSf,
+      borrows: dec.borrows.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.ObligationLiquidity.fromDecoded(item)
+      ),
+      borrowFactorAdjustedDebtValueSf: dec.borrowFactorAdjustedDebtValueSf,
+      borrowedAssetsMarketValueSf: dec.borrowedAssetsMarketValueSf,
+      allowedBorrowValueSf: dec.allowedBorrowValueSf,
+      unhealthyBorrowValueSf: dec.unhealthyBorrowValueSf,
+      depositsAssetTiers: dec.depositsAssetTiers,
+      borrowsAssetTiers: dec.borrowsAssetTiers,
+      elevationGroup: dec.elevationGroup,
+      numOfObsoleteReserves: dec.numOfObsoleteReserves,
+      hasDebt: dec.hasDebt,
+      referrer: dec.referrer,
+      borrowingDisabled: dec.borrowingDisabled,
+      reserved: dec.reserved,
+      highestBorrowFactorPct: dec.highestBorrowFactorPct,
+      padding3: dec.padding3,
+    })
+  }
+
+  toJSON(): ObligationJSON {
+    return {
+      tag: this.tag.toString(),
+      lastUpdate: this.lastUpdate.toJSON(),
+      lendingMarket: this.lendingMarket.toString(),
+      owner: this.owner.toString(),
+      deposits: this.deposits.map((item) => item.toJSON()),
+      lowestReserveDepositLiquidationLtv:
+        this.lowestReserveDepositLiquidationLtv.toString(),
+      depositedValueSf: this.depositedValueSf.toString(),
+      borrows: this.borrows.map((item) => item.toJSON()),
+      borrowFactorAdjustedDebtValueSf:
+        this.borrowFactorAdjustedDebtValueSf.toString(),
+      borrowedAssetsMarketValueSf: this.borrowedAssetsMarketValueSf.toString(),
+      allowedBorrowValueSf: this.allowedBorrowValueSf.toString(),
+      unhealthyBorrowValueSf: this.unhealthyBorrowValueSf.toString(),
+      depositsAssetTiers: this.depositsAssetTiers,
+      borrowsAssetTiers: this.borrowsAssetTiers,
+      elevationGroup: this.elevationGroup,
+      numOfObsoleteReserves: this.numOfObsoleteReserves,
+      hasDebt: this.hasDebt,
+      referrer: this.referrer.toString(),
+      borrowingDisabled: this.borrowingDisabled,
+      reserved: this.reserved,
+      highestBorrowFactorPct: this.highestBorrowFactorPct.toString(),
+      padding3: this.padding3.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ObligationJSON): Obligation {
+    return new Obligation({
+      tag: new BN(obj.tag),
+      lastUpdate: types.LastUpdate.fromJSON(obj.lastUpdate),
+      lendingMarket: new PublicKey(obj.lendingMarket),
+      owner: new PublicKey(obj.owner),
+      deposits: obj.deposits.map((item) =>
+        types.ObligationCollateral.fromJSON(item)
+      ),
+      lowestReserveDepositLiquidationLtv: new BN(
+        obj.lowestReserveDepositLiquidationLtv
+      ),
+      depositedValueSf: new BN(obj.depositedValueSf),
+      borrows: obj.borrows.map((item) =>
+        types.ObligationLiquidity.fromJSON(item)
+      ),
+      borrowFactorAdjustedDebtValueSf: new BN(
+        obj.borrowFactorAdjustedDebtValueSf
+      ),
+      borrowedAssetsMarketValueSf: new BN(obj.borrowedAssetsMarketValueSf),
+      allowedBorrowValueSf: new BN(obj.allowedBorrowValueSf),
+      unhealthyBorrowValueSf: new BN(obj.unhealthyBorrowValueSf),
+      depositsAssetTiers: obj.depositsAssetTiers,
+      borrowsAssetTiers: obj.borrowsAssetTiers,
+      elevationGroup: obj.elevationGroup,
+      numOfObsoleteReserves: obj.numOfObsoleteReserves,
+      hasDebt: obj.hasDebt,
+      referrer: new PublicKey(obj.referrer),
+      borrowingDisabled: obj.borrowingDisabled,
+      reserved: obj.reserved,
+      highestBorrowFactorPct: new BN(obj.highestBorrowFactorPct),
+      padding3: obj.padding3.map((item) => new BN(item)),
+    })
+  }
+}

package/src/accounts/ReferrerState.ts

@@ -0,0 +1,90 @@
+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 ReferrerStateFields {
+  shortUrl: PublicKey
+  owner: PublicKey
+}
+
+export interface ReferrerStateJSON {
+  shortUrl: string
+  owner: string
+}
+
+export class ReferrerState {
+  readonly shortUrl: PublicKey
+  readonly owner: PublicKey
+
+  static readonly discriminator = Buffer.from([194, 81, 217, 103, 12, 19, 12, 66])
+
+  static readonly layout = borsh.struct([borsh.publicKey("shortUrl"), borsh.publicKey("owner")])
+
+  constructor(fields: ReferrerStateFields) {
+    this.shortUrl = fields.shortUrl
+    this.owner = fields.owner
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<ReferrerState | 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<ReferrerState | 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): ReferrerState {
+    if (!data.slice(0, 8).equals(ReferrerState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ReferrerState.layout.decode(data.slice(8))
+
+    return new ReferrerState({
+      shortUrl: dec.shortUrl,
+      owner: dec.owner,
+    })
+  }
+
+  toJSON(): ReferrerStateJSON {
+    return {
+      shortUrl: this.shortUrl.toString(),
+      owner: this.owner.toString(),
+    }
+  }
+
+  static fromJSON(obj: ReferrerStateJSON): ReferrerState {
+    return new ReferrerState({
+      shortUrl: new PublicKey(obj.shortUrl),
+      owner: new PublicKey(obj.owner),
+    })
+  }
+}

package/src/accounts/ReferrerTokenState.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 ReferrerTokenStateFields {
+  referrer: PublicKey
+  mint: PublicKey
+  amountUnclaimedSf: BN
+  amountCumulativeSf: BN
+  bump: BN
+  padding: Array<BN>
+}
+
+export interface ReferrerTokenStateJSON {
+  referrer: string
+  mint: string
+  amountUnclaimedSf: string
+  amountCumulativeSf: string
+  bump: string
+  padding: Array<string>
+}
+
+export class ReferrerTokenState {
+  readonly referrer: PublicKey
+  readonly mint: PublicKey
+  readonly amountUnclaimedSf: BN
+  readonly amountCumulativeSf: BN
+  readonly bump: BN
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([39, 15, 208, 77, 32, 195, 105, 56])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("referrer"),
+    borsh.publicKey("mint"),
+    borsh.u128("amountUnclaimedSf"),
+    borsh.u128("amountCumulativeSf"),
+    borsh.u64("bump"),
+    borsh.array(borsh.u64(), 31, "padding"),
+  ])
+
+  constructor(fields: ReferrerTokenStateFields) {
+    this.referrer = fields.referrer
+    this.mint = fields.mint
+    this.amountUnclaimedSf = fields.amountUnclaimedSf
+    this.amountCumulativeSf = fields.amountCumulativeSf
+    this.bump = fields.bump
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID,
+  ): Promise<ReferrerTokenState | 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<ReferrerTokenState | 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): ReferrerTokenState {
+    if (!data.slice(0, 8).equals(ReferrerTokenState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ReferrerTokenState.layout.decode(data.slice(8))
+
+    return new ReferrerTokenState({
+      referrer: dec.referrer,
+      mint: dec.mint,
+      amountUnclaimedSf: dec.amountUnclaimedSf,
+      amountCumulativeSf: dec.amountCumulativeSf,
+      bump: dec.bump,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): ReferrerTokenStateJSON {
+    return {
+      referrer: this.referrer.toString(),
+      mint: this.mint.toString(),
+      amountUnclaimedSf: this.amountUnclaimedSf.toString(),
+      amountCumulativeSf: this.amountCumulativeSf.toString(),
+      bump: this.bump.toString(),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ReferrerTokenStateJSON): ReferrerTokenState {
+    return new ReferrerTokenState({
+      referrer: new PublicKey(obj.referrer),
+      mint: new PublicKey(obj.mint),
+      amountUnclaimedSf: new BN(obj.amountUnclaimedSf),
+      amountCumulativeSf: new BN(obj.amountCumulativeSf),
+      bump: new BN(obj.bump),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}