@exponent-labs/loopscale-deserializer 0.9.0

package/src/index.ts

@@ -0,0 +1,504 @@
+import * as borsh from "@coral-xyz/borsh"
+import { Connection, PublicKey } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import Decimal from "decimal.js"
+
+import {
+  CapMonitor,
+  CapMonitorFields,
+  CapMonitorJSON,
+  CollateralData,
+  CollateralDataFields,
+  CollateralDataJSON,
+  Duration,
+  ExternalYieldAccounts,
+  ExternalYieldAccountsFields,
+  ExternalYieldAccountsJSON,
+  Ledger,
+  LedgerFields,
+  LedgerJSON,
+} from "./types"
+
+export { CapMonitor, CollateralData, Duration, ExternalYieldAccounts, Ledger }
+
+export const PROGRAM_ID = new PublicKey("1oopBoJG58DgkUVKkEzKgyG9dvRmpgeEm1AVjoHkF78")
+
+const POD_DECIMAL_SCALE = new Decimal(10).pow(18)
+
+/** Convert a PodDecimal (3 x u64 LE = 192-bit LE integer scaled by 10^18) to Decimal */
+export function podDecimalToDecimal(parts: BN[]): Decimal {
+  const lo = BigInt(parts[0].toString())
+  const mid = BigInt(parts[1].toString()) << BigInt(64)
+  const hi = BigInt(parts[2].toString()) << BigInt(128)
+  const raw = lo + mid + hi
+  return new Decimal(raw.toString()).div(POD_DECIMAL_SCALE)
+}
+
+// ============================================================================
+// Loan
+// ============================================================================
+
+export interface LoanFields {
+  version: number
+  bump: number
+  loanStatus: number
+  borrower: PublicKey
+  nonce: BN
+  startTime: BN
+  ledgers: Array<LedgerFields>
+  collateral: Array<CollateralDataFields>
+  weightMatrix: Array<Array<number>>
+  ltvMatrix: Array<Array<number>>
+  lqtMatrix: Array<Array<number>>
+}
+
+export interface LoanJSON {
+  version: number
+  bump: number
+  loanStatus: number
+  borrower: string
+  nonce: string
+  startTime: string
+  ledgers: Array<LedgerJSON>
+  collateral: Array<CollateralDataJSON>
+  weightMatrix: Array<Array<number>>
+  ltvMatrix: Array<Array<number>>
+  lqtMatrix: Array<Array<number>>
+}
+
+export class Loan {
+  readonly version: number
+  readonly bump: number
+  readonly loanStatus: number
+  readonly borrower: PublicKey
+  readonly nonce: BN
+  readonly startTime: BN
+  readonly ledgers: Array<Ledger>
+  readonly collateral: Array<CollateralData>
+  readonly weightMatrix: Array<Array<number>>
+  readonly ltvMatrix: Array<Array<number>>
+  readonly lqtMatrix: Array<Array<number>>
+
+  static readonly discriminator = Buffer.from([20, 195, 70, 117, 165, 227, 182, 1])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("version"),
+    borsh.u8("bump"),
+    borsh.u8("loanStatus"),
+    borsh.publicKey("borrower"),
+    borsh.u64("nonce"),
+    borsh.u64("startTime"),
+    borsh.array(Ledger.layout(), 5, "ledgers"),
+    borsh.array(CollateralData.layout(), 5, "collateral"),
+    borsh.array(borsh.array(borsh.u32(), 5), 5, "weightMatrix"),
+    borsh.array(borsh.array(borsh.u32(), 5), 5, "ltvMatrix"),
+    borsh.array(borsh.array(borsh.u32(), 5), 5, "lqtMatrix"),
+  ])
+
+  constructor(fields: LoanFields) {
+    this.version = fields.version
+    this.bump = fields.bump
+    this.loanStatus = fields.loanStatus
+    this.borrower = fields.borrower
+    this.nonce = fields.nonce
+    this.startTime = fields.startTime
+    this.ledgers = fields.ledgers.map((l) => new Ledger({ ...l }))
+    this.collateral = fields.collateral.map((c) => new CollateralData({ ...c }))
+    this.weightMatrix = fields.weightMatrix
+    this.ltvMatrix = fields.ltvMatrix
+    this.lqtMatrix = fields.lqtMatrix
+  }
+
+  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<Loan | 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<Loan | 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): Loan {
+    if (!data.slice(0, 8).equals(Loan.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Loan.layout.decode(data.slice(8))
+
+    return new Loan({
+      version: dec.version,
+      bump: dec.bump,
+      loanStatus: dec.loanStatus,
+      borrower: dec.borrower,
+      nonce: dec.nonce,
+      startTime: dec.startTime,
+      ledgers: dec.ledgers.map((l: any) => Ledger.fromDecoded(l)), // eslint-disable-line @typescript-eslint/no-explicit-any
+      collateral: dec.collateral.map((c: any) => CollateralData.fromDecoded(c)), // eslint-disable-line @typescript-eslint/no-explicit-any
+      weightMatrix: dec.weightMatrix,
+      ltvMatrix: dec.ltvMatrix,
+      lqtMatrix: dec.lqtMatrix,
+    })
+  }
+
+  toJSON(): LoanJSON {
+    return {
+      version: this.version,
+      bump: this.bump,
+      loanStatus: this.loanStatus,
+      borrower: this.borrower.toString(),
+      nonce: this.nonce.toString(),
+      startTime: this.startTime.toString(),
+      ledgers: this.ledgers.map((l) => l.toJSON()),
+      collateral: this.collateral.map((c) => c.toJSON()),
+      weightMatrix: this.weightMatrix,
+      ltvMatrix: this.ltvMatrix,
+      lqtMatrix: this.lqtMatrix,
+    }
+  }
+
+  static fromJSON(obj: LoanJSON): Loan {
+    return new Loan({
+      version: obj.version,
+      bump: obj.bump,
+      loanStatus: obj.loanStatus,
+      borrower: new PublicKey(obj.borrower),
+      nonce: new BN(obj.nonce),
+      startTime: new BN(obj.startTime),
+      ledgers: obj.ledgers.map((l) => Ledger.fromJSON(l)),
+      collateral: obj.collateral.map((c) => CollateralData.fromJSON(c)),
+      weightMatrix: obj.weightMatrix,
+      ltvMatrix: obj.ltvMatrix,
+      lqtMatrix: obj.lqtMatrix,
+    })
+  }
+}
+
+// ============================================================================
+// Strategy
+// ============================================================================
+
+export interface StrategyFields {
+  version: number
+  nonce: PublicKey
+  bump: number
+  principalMint: PublicKey
+  lender: PublicKey
+  originationsEnabled: number
+  externalYieldSource: number
+  /** PodDecimal: 24 bytes stored as 3 x u64 */
+  interestPerSecond: Array<BN>
+  lastAccruedTimestamp: BN
+  liquidityBuffer: BN
+  tokenBalance: BN
+  interestFee: BN
+  principalFee: BN
+  originationFee: BN
+  originationCap: BN
+  externalYieldAmount: BN
+  currentDeployedAmount: BN
+  outstandingInterestAmount: BN
+  feeClaimable: BN
+  cumulativePrincipalOriginated: BN
+  cumulativeInterestAccrued: BN
+  cumulativeLoanCount: BN
+  activeLoanCount: BN
+  marketInformation: PublicKey
+  collateralMap: Array<Array<BN>>
+  externalYieldAccounts: ExternalYieldAccountsFields
+  supplyMonitor: CapMonitorFields
+  withdrawMonitor: CapMonitorFields
+  borrowMonitor: CapMonitorFields
+}
+
+export interface StrategyJSON {
+  version: number
+  nonce: string
+  bump: number
+  principalMint: string
+  lender: string
+  originationsEnabled: number
+  externalYieldSource: number
+  interestPerSecond: Array<string>
+  lastAccruedTimestamp: string
+  liquidityBuffer: string
+  tokenBalance: string
+  interestFee: string
+  principalFee: string
+  originationFee: string
+  originationCap: string
+  externalYieldAmount: string
+  currentDeployedAmount: string
+  outstandingInterestAmount: string
+  feeClaimable: string
+  cumulativePrincipalOriginated: string
+  cumulativeInterestAccrued: string
+  cumulativeLoanCount: string
+  activeLoanCount: string
+  marketInformation: string
+  collateralMap: Array<Array<string>>
+  externalYieldAccounts: ExternalYieldAccountsJSON
+  supplyMonitor: CapMonitorJSON
+  withdrawMonitor: CapMonitorJSON
+  borrowMonitor: CapMonitorJSON
+}
+
+export class Strategy {
+  readonly version: number
+  readonly nonce: PublicKey
+  readonly bump: number
+  readonly principalMint: PublicKey
+  readonly lender: PublicKey
+  readonly originationsEnabled: number
+  readonly externalYieldSource: number
+  readonly interestPerSecond: Array<BN>
+  readonly lastAccruedTimestamp: BN
+  readonly liquidityBuffer: BN
+  readonly tokenBalance: BN
+  readonly interestFee: BN
+  readonly principalFee: BN
+  readonly originationFee: BN
+  readonly originationCap: BN
+  readonly externalYieldAmount: BN
+  readonly currentDeployedAmount: BN
+  readonly outstandingInterestAmount: BN
+  readonly feeClaimable: BN
+  readonly cumulativePrincipalOriginated: BN
+  readonly cumulativeInterestAccrued: BN
+  readonly cumulativeLoanCount: BN
+  readonly activeLoanCount: BN
+  readonly marketInformation: PublicKey
+  readonly collateralMap: Array<Array<BN>>
+  readonly externalYieldAccounts: ExternalYieldAccounts
+  readonly supplyMonitor: CapMonitor
+  readonly withdrawMonitor: CapMonitor
+  readonly borrowMonitor: CapMonitor
+
+  static readonly discriminator = Buffer.from([174, 110, 39, 119, 82, 106, 169, 102])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("version"),
+    borsh.publicKey("nonce"),
+    borsh.u8("bump"),
+    borsh.publicKey("principalMint"),
+    borsh.publicKey("lender"),
+    borsh.u8("originationsEnabled"),
+    borsh.u8("externalYieldSource"),
+    borsh.array(borsh.u64(), 3, "interestPerSecond"),
+    borsh.u64("lastAccruedTimestamp"),
+    borsh.u64("liquidityBuffer"),
+    borsh.u64("tokenBalance"),
+    borsh.u64("interestFee"),
+    borsh.u64("principalFee"),
+    borsh.u64("originationFee"),
+    borsh.u64("originationCap"),
+    borsh.u64("externalYieldAmount"),
+    borsh.u64("currentDeployedAmount"),
+    borsh.u64("outstandingInterestAmount"),
+    borsh.u64("feeClaimable"),
+    borsh.u128("cumulativePrincipalOriginated"),
+    borsh.u128("cumulativeInterestAccrued"),
+    borsh.u64("cumulativeLoanCount"),
+    borsh.u64("activeLoanCount"),
+    borsh.publicKey("marketInformation"),
+    borsh.array(borsh.array(borsh.u64(), 5), 200, "collateralMap"),
+    ExternalYieldAccounts.layout("externalYieldAccounts"),
+    CapMonitor.layout("supplyMonitor"),
+    CapMonitor.layout("withdrawMonitor"),
+    CapMonitor.layout("borrowMonitor"),
+  ])
+
+  constructor(fields: StrategyFields) {
+    this.version = fields.version
+    this.nonce = fields.nonce
+    this.bump = fields.bump
+    this.principalMint = fields.principalMint
+    this.lender = fields.lender
+    this.originationsEnabled = fields.originationsEnabled
+    this.externalYieldSource = fields.externalYieldSource
+    this.interestPerSecond = fields.interestPerSecond
+    this.lastAccruedTimestamp = fields.lastAccruedTimestamp
+    this.liquidityBuffer = fields.liquidityBuffer
+    this.tokenBalance = fields.tokenBalance
+    this.interestFee = fields.interestFee
+    this.principalFee = fields.principalFee
+    this.originationFee = fields.originationFee
+    this.originationCap = fields.originationCap
+    this.externalYieldAmount = fields.externalYieldAmount
+    this.currentDeployedAmount = fields.currentDeployedAmount
+    this.outstandingInterestAmount = fields.outstandingInterestAmount
+    this.feeClaimable = fields.feeClaimable
+    this.cumulativePrincipalOriginated = fields.cumulativePrincipalOriginated
+    this.cumulativeInterestAccrued = fields.cumulativeInterestAccrued
+    this.cumulativeLoanCount = fields.cumulativeLoanCount
+    this.activeLoanCount = fields.activeLoanCount
+    this.marketInformation = fields.marketInformation
+    this.collateralMap = fields.collateralMap
+    this.externalYieldAccounts = new ExternalYieldAccounts({ ...fields.externalYieldAccounts })
+    this.supplyMonitor = new CapMonitor({ ...fields.supplyMonitor })
+    this.withdrawMonitor = new CapMonitor({ ...fields.withdrawMonitor })
+    this.borrowMonitor = new CapMonitor({ ...fields.borrowMonitor })
+  }
+
+  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<Strategy | 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<Strategy | 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): Strategy {
+    if (!data.slice(0, 8).equals(Strategy.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Strategy.layout.decode(data.slice(8))
+
+    return new Strategy({
+      version: dec.version,
+      nonce: dec.nonce,
+      bump: dec.bump,
+      principalMint: dec.principalMint,
+      lender: dec.lender,
+      originationsEnabled: dec.originationsEnabled,
+      externalYieldSource: dec.externalYieldSource,
+      interestPerSecond: dec.interestPerSecond,
+      lastAccruedTimestamp: dec.lastAccruedTimestamp,
+      liquidityBuffer: dec.liquidityBuffer,
+      tokenBalance: dec.tokenBalance,
+      interestFee: dec.interestFee,
+      principalFee: dec.principalFee,
+      originationFee: dec.originationFee,
+      originationCap: dec.originationCap,
+      externalYieldAmount: dec.externalYieldAmount,
+      currentDeployedAmount: dec.currentDeployedAmount,
+      outstandingInterestAmount: dec.outstandingInterestAmount,
+      feeClaimable: dec.feeClaimable,
+      cumulativePrincipalOriginated: dec.cumulativePrincipalOriginated,
+      cumulativeInterestAccrued: dec.cumulativeInterestAccrued,
+      cumulativeLoanCount: dec.cumulativeLoanCount,
+      activeLoanCount: dec.activeLoanCount,
+      marketInformation: dec.marketInformation,
+      collateralMap: dec.collateralMap,
+      externalYieldAccounts: ExternalYieldAccounts.fromDecoded(dec.externalYieldAccounts),
+      supplyMonitor: CapMonitor.fromDecoded(dec.supplyMonitor),
+      withdrawMonitor: CapMonitor.fromDecoded(dec.withdrawMonitor),
+      borrowMonitor: CapMonitor.fromDecoded(dec.borrowMonitor),
+    })
+  }
+
+  toJSON(): StrategyJSON {
+    return {
+      version: this.version,
+      nonce: this.nonce.toString(),
+      bump: this.bump,
+      principalMint: this.principalMint.toString(),
+      lender: this.lender.toString(),
+      originationsEnabled: this.originationsEnabled,
+      externalYieldSource: this.externalYieldSource,
+      interestPerSecond: this.interestPerSecond.map((item) => item.toString()),
+      lastAccruedTimestamp: this.lastAccruedTimestamp.toString(),
+      liquidityBuffer: this.liquidityBuffer.toString(),
+      tokenBalance: this.tokenBalance.toString(),
+      interestFee: this.interestFee.toString(),
+      principalFee: this.principalFee.toString(),
+      originationFee: this.originationFee.toString(),
+      originationCap: this.originationCap.toString(),
+      externalYieldAmount: this.externalYieldAmount.toString(),
+      currentDeployedAmount: this.currentDeployedAmount.toString(),
+      outstandingInterestAmount: this.outstandingInterestAmount.toString(),
+      feeClaimable: this.feeClaimable.toString(),
+      cumulativePrincipalOriginated: this.cumulativePrincipalOriginated.toString(),
+      cumulativeInterestAccrued: this.cumulativeInterestAccrued.toString(),
+      cumulativeLoanCount: this.cumulativeLoanCount.toString(),
+      activeLoanCount: this.activeLoanCount.toString(),
+      marketInformation: this.marketInformation.toString(),
+      collateralMap: this.collateralMap.map((row) => row.map((item) => item.toString())),
+      externalYieldAccounts: this.externalYieldAccounts.toJSON(),
+      supplyMonitor: this.supplyMonitor.toJSON(),
+      withdrawMonitor: this.withdrawMonitor.toJSON(),
+      borrowMonitor: this.borrowMonitor.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: StrategyJSON): Strategy {
+    return new Strategy({
+      version: obj.version,
+      nonce: new PublicKey(obj.nonce),
+      bump: obj.bump,
+      principalMint: new PublicKey(obj.principalMint),
+      lender: new PublicKey(obj.lender),
+      originationsEnabled: obj.originationsEnabled,
+      externalYieldSource: obj.externalYieldSource,
+      interestPerSecond: obj.interestPerSecond.map((item) => new BN(item)),
+      lastAccruedTimestamp: new BN(obj.lastAccruedTimestamp),
+      liquidityBuffer: new BN(obj.liquidityBuffer),
+      tokenBalance: new BN(obj.tokenBalance),
+      interestFee: new BN(obj.interestFee),
+      principalFee: new BN(obj.principalFee),
+      originationFee: new BN(obj.originationFee),
+      originationCap: new BN(obj.originationCap),
+      externalYieldAmount: new BN(obj.externalYieldAmount),
+      currentDeployedAmount: new BN(obj.currentDeployedAmount),
+      outstandingInterestAmount: new BN(obj.outstandingInterestAmount),
+      feeClaimable: new BN(obj.feeClaimable),
+      cumulativePrincipalOriginated: new BN(obj.cumulativePrincipalOriginated),
+      cumulativeInterestAccrued: new BN(obj.cumulativeInterestAccrued),
+      cumulativeLoanCount: new BN(obj.cumulativeLoanCount),
+      activeLoanCount: new BN(obj.activeLoanCount),
+      marketInformation: new PublicKey(obj.marketInformation),
+      collateralMap: obj.collateralMap.map((row) => row.map((item) => new BN(item))),
+      externalYieldAccounts: ExternalYieldAccounts.fromJSON(obj.externalYieldAccounts),
+      supplyMonitor: CapMonitor.fromJSON(obj.supplyMonitor),
+      withdrawMonitor: CapMonitor.fromJSON(obj.withdrawMonitor),
+      borrowMonitor: CapMonitor.fromJSON(obj.borrowMonitor),
+    })
+  }
+}