@exponent-labs/klend-idl 0.9.0

package/src/types/ReserveLiquidity.ts

@@ -0,0 +1,219 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ReserveLiquidityFields {
+  mintPubkey: PublicKey
+  supplyVault: PublicKey
+  feeVault: PublicKey
+  availableAmount: BN
+  borrowedAmountSf: BN
+  marketPriceSf: BN
+  marketPriceLastUpdatedTs: BN
+  mintDecimals: BN
+  depositLimitCrossedSlot: BN
+  borrowLimitCrossedSlot: BN
+  cumulativeBorrowRateBsf: types.BigFractionBytesFields
+  accumulatedProtocolFeesSf: BN
+  accumulatedReferrerFeesSf: BN
+  pendingReferrerFeesSf: BN
+  absoluteReferralRateSf: BN
+  tokenProgram: PublicKey
+  padding2: Array<BN>
+  padding3: Array<BN>
+}
+
+export interface ReserveLiquidityJSON {
+  mintPubkey: string
+  supplyVault: string
+  feeVault: string
+  availableAmount: string
+  borrowedAmountSf: string
+  marketPriceSf: string
+  marketPriceLastUpdatedTs: string
+  mintDecimals: string
+  depositLimitCrossedSlot: string
+  borrowLimitCrossedSlot: string
+  cumulativeBorrowRateBsf: types.BigFractionBytesJSON
+  accumulatedProtocolFeesSf: string
+  accumulatedReferrerFeesSf: string
+  pendingReferrerFeesSf: string
+  absoluteReferralRateSf: string
+  tokenProgram: string
+  padding2: Array<string>
+  padding3: Array<string>
+}
+
+export class ReserveLiquidity {
+  readonly mintPubkey: PublicKey
+  readonly supplyVault: PublicKey
+  readonly feeVault: PublicKey
+  readonly availableAmount: BN
+  readonly borrowedAmountSf: BN
+  readonly marketPriceSf: BN
+  readonly marketPriceLastUpdatedTs: BN
+  readonly mintDecimals: BN
+  readonly depositLimitCrossedSlot: BN
+  readonly borrowLimitCrossedSlot: BN
+  readonly cumulativeBorrowRateBsf: types.BigFractionBytes
+  readonly accumulatedProtocolFeesSf: BN
+  readonly accumulatedReferrerFeesSf: BN
+  readonly pendingReferrerFeesSf: BN
+  readonly absoluteReferralRateSf: BN
+  readonly tokenProgram: PublicKey
+  readonly padding2: Array<BN>
+  readonly padding3: Array<BN>
+
+  constructor(fields: ReserveLiquidityFields) {
+    this.mintPubkey = fields.mintPubkey
+    this.supplyVault = fields.supplyVault
+    this.feeVault = fields.feeVault
+    this.availableAmount = fields.availableAmount
+    this.borrowedAmountSf = fields.borrowedAmountSf
+    this.marketPriceSf = fields.marketPriceSf
+    this.marketPriceLastUpdatedTs = fields.marketPriceLastUpdatedTs
+    this.mintDecimals = fields.mintDecimals
+    this.depositLimitCrossedSlot = fields.depositLimitCrossedSlot
+    this.borrowLimitCrossedSlot = fields.borrowLimitCrossedSlot
+    this.cumulativeBorrowRateBsf = new types.BigFractionBytes({
+      ...fields.cumulativeBorrowRateBsf,
+    })
+    this.accumulatedProtocolFeesSf = fields.accumulatedProtocolFeesSf
+    this.accumulatedReferrerFeesSf = fields.accumulatedReferrerFeesSf
+    this.pendingReferrerFeesSf = fields.pendingReferrerFeesSf
+    this.absoluteReferralRateSf = fields.absoluteReferralRateSf
+    this.tokenProgram = fields.tokenProgram
+    this.padding2 = fields.padding2
+    this.padding3 = fields.padding3
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("mintPubkey"),
+        borsh.publicKey("supplyVault"),
+        borsh.publicKey("feeVault"),
+        borsh.u64("availableAmount"),
+        borsh.u128("borrowedAmountSf"),
+        borsh.u128("marketPriceSf"),
+        borsh.u64("marketPriceLastUpdatedTs"),
+        borsh.u64("mintDecimals"),
+        borsh.u64("depositLimitCrossedSlot"),
+        borsh.u64("borrowLimitCrossedSlot"),
+        types.BigFractionBytes.layout("cumulativeBorrowRateBsf"),
+        borsh.u128("accumulatedProtocolFeesSf"),
+        borsh.u128("accumulatedReferrerFeesSf"),
+        borsh.u128("pendingReferrerFeesSf"),
+        borsh.u128("absoluteReferralRateSf"),
+        borsh.publicKey("tokenProgram"),
+        borsh.array(borsh.u64(), 51, "padding2"),
+        borsh.array(borsh.u128(), 32, "padding3"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ReserveLiquidity({
+      mintPubkey: obj.mintPubkey,
+      supplyVault: obj.supplyVault,
+      feeVault: obj.feeVault,
+      availableAmount: obj.availableAmount,
+      borrowedAmountSf: obj.borrowedAmountSf,
+      marketPriceSf: obj.marketPriceSf,
+      marketPriceLastUpdatedTs: obj.marketPriceLastUpdatedTs,
+      mintDecimals: obj.mintDecimals,
+      depositLimitCrossedSlot: obj.depositLimitCrossedSlot,
+      borrowLimitCrossedSlot: obj.borrowLimitCrossedSlot,
+      cumulativeBorrowRateBsf: types.BigFractionBytes.fromDecoded(
+        obj.cumulativeBorrowRateBsf
+      ),
+      accumulatedProtocolFeesSf: obj.accumulatedProtocolFeesSf,
+      accumulatedReferrerFeesSf: obj.accumulatedReferrerFeesSf,
+      pendingReferrerFeesSf: obj.pendingReferrerFeesSf,
+      absoluteReferralRateSf: obj.absoluteReferralRateSf,
+      tokenProgram: obj.tokenProgram,
+      padding2: obj.padding2,
+      padding3: obj.padding3,
+    })
+  }
+
+  static toEncodable(fields: ReserveLiquidityFields) {
+    return {
+      mintPubkey: fields.mintPubkey,
+      supplyVault: fields.supplyVault,
+      feeVault: fields.feeVault,
+      availableAmount: fields.availableAmount,
+      borrowedAmountSf: fields.borrowedAmountSf,
+      marketPriceSf: fields.marketPriceSf,
+      marketPriceLastUpdatedTs: fields.marketPriceLastUpdatedTs,
+      mintDecimals: fields.mintDecimals,
+      depositLimitCrossedSlot: fields.depositLimitCrossedSlot,
+      borrowLimitCrossedSlot: fields.borrowLimitCrossedSlot,
+      cumulativeBorrowRateBsf: types.BigFractionBytes.toEncodable(
+        fields.cumulativeBorrowRateBsf
+      ),
+      accumulatedProtocolFeesSf: fields.accumulatedProtocolFeesSf,
+      accumulatedReferrerFeesSf: fields.accumulatedReferrerFeesSf,
+      pendingReferrerFeesSf: fields.pendingReferrerFeesSf,
+      absoluteReferralRateSf: fields.absoluteReferralRateSf,
+      tokenProgram: fields.tokenProgram,
+      padding2: fields.padding2,
+      padding3: fields.padding3,
+    }
+  }
+
+  toJSON(): ReserveLiquidityJSON {
+    return {
+      mintPubkey: this.mintPubkey.toString(),
+      supplyVault: this.supplyVault.toString(),
+      feeVault: this.feeVault.toString(),
+      availableAmount: this.availableAmount.toString(),
+      borrowedAmountSf: this.borrowedAmountSf.toString(),
+      marketPriceSf: this.marketPriceSf.toString(),
+      marketPriceLastUpdatedTs: this.marketPriceLastUpdatedTs.toString(),
+      mintDecimals: this.mintDecimals.toString(),
+      depositLimitCrossedSlot: this.depositLimitCrossedSlot.toString(),
+      borrowLimitCrossedSlot: this.borrowLimitCrossedSlot.toString(),
+      cumulativeBorrowRateBsf: this.cumulativeBorrowRateBsf.toJSON(),
+      accumulatedProtocolFeesSf: this.accumulatedProtocolFeesSf.toString(),
+      accumulatedReferrerFeesSf: this.accumulatedReferrerFeesSf.toString(),
+      pendingReferrerFeesSf: this.pendingReferrerFeesSf.toString(),
+      absoluteReferralRateSf: this.absoluteReferralRateSf.toString(),
+      tokenProgram: this.tokenProgram.toString(),
+      padding2: this.padding2.map((item) => item.toString()),
+      padding3: this.padding3.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ReserveLiquidityJSON): ReserveLiquidity {
+    return new ReserveLiquidity({
+      mintPubkey: new PublicKey(obj.mintPubkey),
+      supplyVault: new PublicKey(obj.supplyVault),
+      feeVault: new PublicKey(obj.feeVault),
+      availableAmount: new BN(obj.availableAmount),
+      borrowedAmountSf: new BN(obj.borrowedAmountSf),
+      marketPriceSf: new BN(obj.marketPriceSf),
+      marketPriceLastUpdatedTs: new BN(obj.marketPriceLastUpdatedTs),
+      mintDecimals: new BN(obj.mintDecimals),
+      depositLimitCrossedSlot: new BN(obj.depositLimitCrossedSlot),
+      borrowLimitCrossedSlot: new BN(obj.borrowLimitCrossedSlot),
+      cumulativeBorrowRateBsf: types.BigFractionBytes.fromJSON(
+        obj.cumulativeBorrowRateBsf
+      ),
+      accumulatedProtocolFeesSf: new BN(obj.accumulatedProtocolFeesSf),
+      accumulatedReferrerFeesSf: new BN(obj.accumulatedReferrerFeesSf),
+      pendingReferrerFeesSf: new BN(obj.pendingReferrerFeesSf),
+      absoluteReferralRateSf: new BN(obj.absoluteReferralRateSf),
+      tokenProgram: new PublicKey(obj.tokenProgram),
+      padding2: obj.padding2.map((item) => new BN(item)),
+      padding3: obj.padding3.map((item) => new BN(item)),
+    })
+  }
+
+  toEncodable() {
+    return ReserveLiquidity.toEncodable(this)
+  }
+}

package/src/types/ReserveStatus.ts

@@ -0,0 +1,120 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ActiveJSON {
+  kind: "Active"
+}
+
+export class Active {
+  static readonly discriminator = 0
+  static readonly kind = "Active"
+  readonly discriminator = 0
+  readonly kind = "Active"
+
+  toJSON(): ActiveJSON {
+    return {
+      kind: "Active",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Active: {},
+    }
+  }
+}
+
+export interface ObsoleteJSON {
+  kind: "Obsolete"
+}
+
+export class Obsolete {
+  static readonly discriminator = 1
+  static readonly kind = "Obsolete"
+  readonly discriminator = 1
+  readonly kind = "Obsolete"
+
+  toJSON(): ObsoleteJSON {
+    return {
+      kind: "Obsolete",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Obsolete: {},
+    }
+  }
+}
+
+export interface HiddenJSON {
+  kind: "Hidden"
+}
+
+export class Hidden {
+  static readonly discriminator = 2
+  static readonly kind = "Hidden"
+  readonly discriminator = 2
+  readonly kind = "Hidden"
+
+  toJSON(): HiddenJSON {
+    return {
+      kind: "Hidden",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Hidden: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ReserveStatusKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Active" in obj) {
+    return new Active()
+  }
+  if ("Obsolete" in obj) {
+    return new Obsolete()
+  }
+  if ("Hidden" in obj) {
+    return new Hidden()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.ReserveStatusJSON
+): types.ReserveStatusKind {
+  switch (obj.kind) {
+    case "Active": {
+      return new Active()
+    }
+    case "Obsolete": {
+      return new Obsolete()
+    }
+    case "Hidden": {
+      return new Hidden()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Active"),
+    borsh.struct([], "Obsolete"),
+    borsh.struct([], "Hidden"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/ScopeConfiguration.ts

@@ -0,0 +1,76 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ScopeConfigurationFields {
+  priceFeed: PublicKey
+  priceChain: Array<number>
+  twapChain: Array<number>
+}
+
+export interface ScopeConfigurationJSON {
+  priceFeed: string
+  priceChain: Array<number>
+  twapChain: Array<number>
+}
+
+export class ScopeConfiguration {
+  readonly priceFeed: PublicKey
+  readonly priceChain: Array<number>
+  readonly twapChain: Array<number>
+
+  constructor(fields: ScopeConfigurationFields) {
+    this.priceFeed = fields.priceFeed
+    this.priceChain = fields.priceChain
+    this.twapChain = fields.twapChain
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("priceFeed"),
+        borsh.array(borsh.u16(), 4, "priceChain"),
+        borsh.array(borsh.u16(), 4, "twapChain"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ScopeConfiguration({
+      priceFeed: obj.priceFeed,
+      priceChain: obj.priceChain,
+      twapChain: obj.twapChain,
+    })
+  }
+
+  static toEncodable(fields: ScopeConfigurationFields) {
+    return {
+      priceFeed: fields.priceFeed,
+      priceChain: fields.priceChain,
+      twapChain: fields.twapChain,
+    }
+  }
+
+  toJSON(): ScopeConfigurationJSON {
+    return {
+      priceFeed: this.priceFeed.toString(),
+      priceChain: this.priceChain,
+      twapChain: this.twapChain,
+    }
+  }
+
+  static fromJSON(obj: ScopeConfigurationJSON): ScopeConfiguration {
+    return new ScopeConfiguration({
+      priceFeed: new PublicKey(obj.priceFeed),
+      priceChain: obj.priceChain,
+      twapChain: obj.twapChain,
+    })
+  }
+
+  toEncodable() {
+    return ScopeConfiguration.toEncodable(this)
+  }
+}

package/src/types/SwitchboardConfiguration.ts

@@ -0,0 +1,64 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface SwitchboardConfigurationFields {
+  priceAggregator: PublicKey
+  twapAggregator: PublicKey
+}
+
+export interface SwitchboardConfigurationJSON {
+  priceAggregator: string
+  twapAggregator: string
+}
+
+export class SwitchboardConfiguration {
+  readonly priceAggregator: PublicKey
+  readonly twapAggregator: PublicKey
+
+  constructor(fields: SwitchboardConfigurationFields) {
+    this.priceAggregator = fields.priceAggregator
+    this.twapAggregator = fields.twapAggregator
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.publicKey("priceAggregator"), borsh.publicKey("twapAggregator")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SwitchboardConfiguration({
+      priceAggregator: obj.priceAggregator,
+      twapAggregator: obj.twapAggregator,
+    })
+  }
+
+  static toEncodable(fields: SwitchboardConfigurationFields) {
+    return {
+      priceAggregator: fields.priceAggregator,
+      twapAggregator: fields.twapAggregator,
+    }
+  }
+
+  toJSON(): SwitchboardConfigurationJSON {
+    return {
+      priceAggregator: this.priceAggregator.toString(),
+      twapAggregator: this.twapAggregator.toString(),
+    }
+  }
+
+  static fromJSON(obj: SwitchboardConfigurationJSON): SwitchboardConfiguration {
+    return new SwitchboardConfiguration({
+      priceAggregator: new PublicKey(obj.priceAggregator),
+      twapAggregator: new PublicKey(obj.twapAggregator),
+    })
+  }
+
+  toEncodable() {
+    return SwitchboardConfiguration.toEncodable(this)
+  }
+}

package/src/types/TokenInfo.ts

@@ -0,0 +1,172 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface TokenInfoFields {
+  name: Array<number>
+  heuristic: types.PriceHeuristicFields
+  maxTwapDivergenceBps: BN
+  maxAgePriceSeconds: BN
+  maxAgeTwapSeconds: BN
+  scopeConfiguration: types.ScopeConfigurationFields
+  switchboardConfiguration: types.SwitchboardConfigurationFields
+  pythConfiguration: types.PythConfigurationFields
+  blockPriceUsage: number
+  reserved: Array<number>
+  padding: Array<BN>
+}
+
+export interface TokenInfoJSON {
+  name: Array<number>
+  heuristic: types.PriceHeuristicJSON
+  maxTwapDivergenceBps: string
+  maxAgePriceSeconds: string
+  maxAgeTwapSeconds: string
+  scopeConfiguration: types.ScopeConfigurationJSON
+  switchboardConfiguration: types.SwitchboardConfigurationJSON
+  pythConfiguration: types.PythConfigurationJSON
+  blockPriceUsage: number
+  reserved: Array<number>
+  padding: Array<string>
+}
+
+export class TokenInfo {
+  readonly name: Array<number>
+  readonly heuristic: types.PriceHeuristic
+  readonly maxTwapDivergenceBps: BN
+  readonly maxAgePriceSeconds: BN
+  readonly maxAgeTwapSeconds: BN
+  readonly scopeConfiguration: types.ScopeConfiguration
+  readonly switchboardConfiguration: types.SwitchboardConfiguration
+  readonly pythConfiguration: types.PythConfiguration
+  readonly blockPriceUsage: number
+  readonly reserved: Array<number>
+  readonly padding: Array<BN>
+
+  constructor(fields: TokenInfoFields) {
+    this.name = fields.name
+    this.heuristic = new types.PriceHeuristic({ ...fields.heuristic })
+    this.maxTwapDivergenceBps = fields.maxTwapDivergenceBps
+    this.maxAgePriceSeconds = fields.maxAgePriceSeconds
+    this.maxAgeTwapSeconds = fields.maxAgeTwapSeconds
+    this.scopeConfiguration = new types.ScopeConfiguration({
+      ...fields.scopeConfiguration,
+    })
+    this.switchboardConfiguration = new types.SwitchboardConfiguration({
+      ...fields.switchboardConfiguration,
+    })
+    this.pythConfiguration = new types.PythConfiguration({
+      ...fields.pythConfiguration,
+    })
+    this.blockPriceUsage = fields.blockPriceUsage
+    this.reserved = fields.reserved
+    this.padding = fields.padding
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.array(borsh.u8(), 32, "name"),
+        types.PriceHeuristic.layout("heuristic"),
+        borsh.u64("maxTwapDivergenceBps"),
+        borsh.u64("maxAgePriceSeconds"),
+        borsh.u64("maxAgeTwapSeconds"),
+        types.ScopeConfiguration.layout("scopeConfiguration"),
+        types.SwitchboardConfiguration.layout("switchboardConfiguration"),
+        types.PythConfiguration.layout("pythConfiguration"),
+        borsh.u8("blockPriceUsage"),
+        borsh.array(borsh.u8(), 7, "reserved"),
+        borsh.array(borsh.u64(), 19, "padding"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new TokenInfo({
+      name: obj.name,
+      heuristic: types.PriceHeuristic.fromDecoded(obj.heuristic),
+      maxTwapDivergenceBps: obj.maxTwapDivergenceBps,
+      maxAgePriceSeconds: obj.maxAgePriceSeconds,
+      maxAgeTwapSeconds: obj.maxAgeTwapSeconds,
+      scopeConfiguration: types.ScopeConfiguration.fromDecoded(
+        obj.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.fromDecoded(
+        obj.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.fromDecoded(
+        obj.pythConfiguration
+      ),
+      blockPriceUsage: obj.blockPriceUsage,
+      reserved: obj.reserved,
+      padding: obj.padding,
+    })
+  }
+
+  static toEncodable(fields: TokenInfoFields) {
+    return {
+      name: fields.name,
+      heuristic: types.PriceHeuristic.toEncodable(fields.heuristic),
+      maxTwapDivergenceBps: fields.maxTwapDivergenceBps,
+      maxAgePriceSeconds: fields.maxAgePriceSeconds,
+      maxAgeTwapSeconds: fields.maxAgeTwapSeconds,
+      scopeConfiguration: types.ScopeConfiguration.toEncodable(
+        fields.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.toEncodable(
+        fields.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.toEncodable(
+        fields.pythConfiguration
+      ),
+      blockPriceUsage: fields.blockPriceUsage,
+      reserved: fields.reserved,
+      padding: fields.padding,
+    }
+  }
+
+  toJSON(): TokenInfoJSON {
+    return {
+      name: this.name,
+      heuristic: this.heuristic.toJSON(),
+      maxTwapDivergenceBps: this.maxTwapDivergenceBps.toString(),
+      maxAgePriceSeconds: this.maxAgePriceSeconds.toString(),
+      maxAgeTwapSeconds: this.maxAgeTwapSeconds.toString(),
+      scopeConfiguration: this.scopeConfiguration.toJSON(),
+      switchboardConfiguration: this.switchboardConfiguration.toJSON(),
+      pythConfiguration: this.pythConfiguration.toJSON(),
+      blockPriceUsage: this.blockPriceUsage,
+      reserved: this.reserved,
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: TokenInfoJSON): TokenInfo {
+    return new TokenInfo({
+      name: obj.name,
+      heuristic: types.PriceHeuristic.fromJSON(obj.heuristic),
+      maxTwapDivergenceBps: new BN(obj.maxTwapDivergenceBps),
+      maxAgePriceSeconds: new BN(obj.maxAgePriceSeconds),
+      maxAgeTwapSeconds: new BN(obj.maxAgeTwapSeconds),
+      scopeConfiguration: types.ScopeConfiguration.fromJSON(
+        obj.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.fromJSON(
+        obj.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.fromJSON(
+        obj.pythConfiguration
+      ),
+      blockPriceUsage: obj.blockPriceUsage,
+      reserved: obj.reserved,
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+
+  toEncodable() {
+    return TokenInfo.toEncodable(this)
+  }
+}