@kamino-finance/klend-sdk 3.2.26 → 4.0.1

package/src/idl_codegen/accounts/Reserve.ts

@@ -0,0 +1,248 @@
+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 of the reserve */
+  version: BN
+  /** Last slot when supply and rates updated */
+  lastUpdate: types.LastUpdateFields
+  /** Lending market address */
+  lendingMarket: PublicKey
+  farmCollateral: PublicKey
+  farmDebt: PublicKey
+  /** Reserve liquidity */
+  liquidity: types.ReserveLiquidityFields
+  reserveLiquidityPadding: Array<BN>
+  /** Reserve collateral */
+  collateral: types.ReserveCollateralFields
+  reserveCollateralPadding: Array<BN>
+  /** Reserve configuration values */
+  config: types.ReserveConfigFields
+  configPadding: Array<BN>
+  borrowedAmountOutsideElevationGroup: BN
+  /**
+   * Amount of token borrowed in lamport of debt asset in the given
+   * elevation group when this reserve is part of the collaterals.
+   */
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  padding: Array<BN>
+}
+
+export interface ReserveJSON {
+  /** Version of the reserve */
+  version: string
+  /** Last slot when supply and rates updated */
+  lastUpdate: types.LastUpdateJSON
+  /** Lending market address */
+  lendingMarket: string
+  farmCollateral: string
+  farmDebt: string
+  /** Reserve liquidity */
+  liquidity: types.ReserveLiquidityJSON
+  reserveLiquidityPadding: Array<string>
+  /** Reserve collateral */
+  collateral: types.ReserveCollateralJSON
+  reserveCollateralPadding: Array<string>
+  /** Reserve configuration values */
+  config: types.ReserveConfigJSON
+  configPadding: Array<string>
+  borrowedAmountOutsideElevationGroup: string
+  /**
+   * Amount of token borrowed in lamport of debt asset in the given
+   * elevation group when this reserve is part of the collaterals.
+   */
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<string>
+  padding: Array<string>
+}
+
+export class Reserve {
+  /** Version of the reserve */
+  readonly version: BN
+  /** Last slot when supply and rates updated */
+  readonly lastUpdate: types.LastUpdate
+  /** Lending market address */
+  readonly lendingMarket: PublicKey
+  readonly farmCollateral: PublicKey
+  readonly farmDebt: PublicKey
+  /** Reserve liquidity */
+  readonly liquidity: types.ReserveLiquidity
+  readonly reserveLiquidityPadding: Array<BN>
+  /** Reserve collateral */
+  readonly collateral: types.ReserveCollateral
+  readonly reserveCollateralPadding: Array<BN>
+  /** Reserve configuration values */
+  readonly config: types.ReserveConfig
+  readonly configPadding: Array<BN>
+  readonly borrowedAmountOutsideElevationGroup: BN
+  /**
+   * Amount of token borrowed in lamport of debt asset in the given
+   * elevation group when this reserve is part of the collaterals.
+   */
+  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/idl_codegen/accounts/ShortUrl.ts

@@ -0,0 +1,97 @@
+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 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/idl_codegen/accounts/UserMetadata.ts

@@ -0,0 +1,142 @@
+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 UserMetadataFields {
+  /** Pubkey of the referrer/owner - pubkey::default if no referrer */
+  referrer: PublicKey
+  /** Bump used for validation of account address */
+  bump: BN
+  /** User lookup table - used to store all user accounts - atas for each reserve mint, each obligation PDA, UserMetadata itself and all referrer_token_states if there is a referrer */
+  userLookupTable: PublicKey
+  /** User metadata account owner */
+  owner: PublicKey
+  padding1: Array<BN>
+  padding2: Array<BN>
+}
+
+export interface UserMetadataJSON {
+  /** Pubkey of the referrer/owner - pubkey::default if no referrer */
+  referrer: string
+  /** Bump used for validation of account address */
+  bump: string
+  /** User lookup table - used to store all user accounts - atas for each reserve mint, each obligation PDA, UserMetadata itself and all referrer_token_states if there is a referrer */
+  userLookupTable: string
+  /** User metadata account owner */
+  owner: string
+  padding1: Array<string>
+  padding2: Array<string>
+}
+
+/** Referrer account -> each owner can have multiple accounts for specific reserves */
+export class UserMetadata {
+  /** Pubkey of the referrer/owner - pubkey::default if no referrer */
+  readonly referrer: PublicKey
+  /** Bump used for validation of account address */
+  readonly bump: BN
+  /** User lookup table - used to store all user accounts - atas for each reserve mint, each obligation PDA, UserMetadata itself and all referrer_token_states if there is a referrer */
+  readonly userLookupTable: PublicKey
+  /** User metadata account owner */
+  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)),
+    })
+  }
+}