hedge-web3 0.1.27 → 0.1.28

package/src/state/VaultAccount.ts

@@ -14,13 +14,16 @@ export class VaultAccount {
 
   /** The public key of the vault owner. */
   pdaSalt: string
-  
+
   /** The deposited collateral of the vault (in SOL Lamports). */
   deposited: number
 
   /** The outstanding debt of the vault (in USH Lamports). Denormalized to time 0. */
   denormalizedDebt: number
 
+  /** The ordered number of when this vault was created. */
+  vaultNumber: number
+
   debtProductSnapshotBytes: Decimal
 
   collateralAccumulatorSnapshotBytes: Decimal
@@ -30,14 +33,19 @@ export class VaultAccount {
   /** Current State of the vautl ("Open", "Closed", "Liquidated") */
   vaultStatus: string
 
-  constructor (vault: any, publicKey: PublicKey) {
+  constructor(vault: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
+    this.vaultNumber = vault.vaultNumber.toNumber()
     this.pdaSalt = vault.pdaSalt
     this.deposited = vault.deposited.toNumber()
     this.denormalizedDebt = vault.denormalizedDebt.toNumber()
-    this.debtProductSnapshotBytes = DecimalFromU128(vault.debtProductSnapshotBytes.toString())
-    this.collateralAccumulatorSnapshotBytes = DecimalFromU128(vault.collateralAccumulatorSnapshotBytes.toString())
+    this.debtProductSnapshotBytes = DecimalFromU128(
+      vault.debtProductSnapshotBytes.toString()
+    )
+    this.collateralAccumulatorSnapshotBytes = DecimalFromU128(
+      vault.collateralAccumulatorSnapshotBytes.toString()
+    )
     this.collateralType = vault.collateralType
 
     this.vaultStatus = Object.keys(vault.vaultStatus)[0]
@@ -49,8 +57,7 @@ export class VaultAccount {
    * @param publicKey the publicKey to check against the vault owner
    * @returns true if publicKey matches the owner publicKey
    */
-  public isOwnedBy (publicKey: PublicKey): boolean {
-
+  public isOwnedBy(publicKey: PublicKey): boolean {
     return publicKey && publicKey.toString() === this.vaultOwner.toString()
   }
 
@@ -59,7 +66,7 @@ export class VaultAccount {
    *
    * @returns collateral value in SOL
    */
-  public inSol (): number {
+  public inSol(): number {
     return this.deposited / LAMPORTS_PER_SOL
   }
 
@@ -68,7 +75,7 @@ export class VaultAccount {
    *
    * @returns debt value in USH
    */
-  public inUsd (): number {
+  public inUsd(): number {
     return this.denormalizedDebt / LAMPORTS_PER_SOL
   }
 
@@ -77,7 +84,76 @@ export class VaultAccount {
    *
    * @returns example: `1b6ca...azy71s`
    */
-  public toDisplayString (): string {
-    return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey.toString().substring(this.publicKey.toString().length - 6)}`
+  public toDisplayString(): string {
+    return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey
+      .toString()
+      .substring(this.publicKey.toString().length - 6)}`
+  }
+
+  public addDebt(
+    newNormalizedDebt: Decimal,
+    vaultTypeCompoundedInterest: Decimal
+  ) {
+    const denormalizedNewDebt = newNormalizedDebt.div(
+      vaultTypeCompoundedInterest
+    )
+    this.denormalizedDebt += denormalizedNewDebt.toNumber()
+  }
+  public addDeposit(depositAmount: number) {
+    this.deposited += depositAmount
+  }
+
+  public redeem() {
+    // TODO - Calculate actual redeem amount and adust correctly
+    this.denormalizedDebt = 0
+    this.vaultStatus = 'initialized'
+  }
+  public liquidate() {
+    // TODO - Calculate actual liquidate amount and adust correctly
+    this.denormalizedDebt = 0
+    this.vaultStatus = 'liquidated'
+  }
+
+  public redistribution(vaultTypeAccuntData: any) {
+    const debtProductCurrent = DecimalFromU128(
+      vaultTypeAccuntData.debtRedistributionProduct
+    )
+
+    const collateralAccumulatorCurrent = DecimalFromU128(
+      vaultTypeAccuntData.collateralRedistributionAccumulator
+    )
+
+    this.denormalizedDebt = debtProductCurrent
+      .div(this.debtProductSnapshotBytes)
+      .mul(new Decimal(this.denormalizedDebt))
+      // .add(new Decimal(vaultTypeAccuntData.debtRedistributionError))
+      .toNumber()
+
+    const extraCollateralDeposited =
+      this.denormalizedDebt *
+      collateralAccumulatorCurrent
+        .sub(this.collateralAccumulatorSnapshotBytes)
+        .toNumber()
+    this.deposited += extraCollateralDeposited
+
+    this.collateralAccumulatorSnapshotBytes = collateralAccumulatorCurrent
+    this.debtProductSnapshotBytes = debtProductCurrent
+  }
+
+  public toString(highlight: PublicKey): string {
+    let arrow = ''
+    if (this.publicKey.toString() === highlight.toString()) {
+      arrow = ' <----'
+    }
+    let collateralRatio = 'Infinite'
+    if (this.denormalizedDebt > 0) {
+      collateralRatio = (this.deposited / this.denormalizedDebt).toFixed(8)
+    }
+    return `Vault(${this.vaultNumber}): ${this.publicKey
+      .toString()
+      .substring(
+        0,
+        6
+      )}. Debt: ${this.inUsd()} Collat: ${collateralRatio} ${arrow}`
   }
 }

package/src/utils/getLinkedListAccounts.ts

@@ -0,0 +1,156 @@
+import { Program, Provider } from '@project-serum/anchor'
+import { PublicKey, Signer } from '@solana/web3.js'
+import _ from 'underscore'
+import {
+  getVaultSystemStatePublicKey,
+  getVaultTypeOracleAccountPublicKey,
+} from '../Constants'
+
+import { DecimalFromU128 } from '../HedgeDecimal'
+import { VaultAccount } from '../state/VaultAccount'
+import Decimal from 'decimal.js'
+export async function getLinkedListAccounts(
+  program: Program,
+  provider: Provider,
+  vaultTypeAccountPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  depositAmount: number,
+  loanAmount: number,
+  redeem: boolean,
+  liquidate: boolean
+): Promise<[PublicKey, PublicKey, PublicKey]> {
+  const vaultTypeAccount = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  )
+
+  // Default for null is the vault itself, so set them all to this vault
+  let oldSmallerPublicKey = vaultPublicKey
+  let newSmallerPublicKey = vaultPublicKey
+  let newLargerPublicKey = vaultPublicKey
+
+  const thisVaultData = await program.account.vault.fetch(vaultPublicKey)
+  const thisVault = new VaultAccount(thisVaultData, vaultPublicKey)
+
+  // Load all the vaults
+  let allVaults =
+    (await program.account.vault
+      .all([
+        // {
+        //   memcmp: { bytes: bs58.encode(inputCollateralType), offset: 8 + 32 + 8 },
+        // },
+      ])
+      .catch((error) => {
+        console.log('error', error)
+      })) || []
+
+  // Load them into our account objects
+  let vaults = allVaults.map((vault) => {
+    return new VaultAccount(vault.account, vault.publicKey)
+  })
+
+  // Filter out the account that are not the same vault type
+  vaults = _.filter(vaults, (vault) => {
+    return vault.collateralType === vaultTypeAccount.collateralType
+  })
+
+  // Filter out the accounts that are not open
+  vaults = _.filter(vaults, (vault) => {
+    return vault.vaultStatus === 'open'
+  })
+
+  // Sort them
+  vaults.sort(sortVaults)
+
+  // Find the location of the vault before the operation
+  let indexBefore = -1
+  vaults.forEach((vault, index) => {
+    if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+      indexBefore = index
+    }
+  })
+
+  // If we found it before, set the old smaller vault the one to the left
+  if (indexBefore > 0) {
+    oldSmallerPublicKey = vaults[indexBefore - 1].publicKey
+  }
+
+  // Pretty print all the vaults before the operation
+  // console.log('Sorted open vaults before')
+  // vaults.forEach((vault) => {
+  //   console.log(vault.toString(vaultPublicKey))
+  // })
+
+  // If it wasn't in the list, add it now
+  if (indexBefore < 0) {
+    vaults.push(thisVault)
+    indexBefore = vaults.length - 1
+  }
+
+  // Now that we know it's def in the list, iterate the list and update
+  // this vault with the opeation we're going to apply
+  const newNormalizedDebt = new Decimal(loanAmount)
+  const vaultTypeCompoundedInterest = DecimalFromU128(
+    vaultTypeAccount.cumulativeRate.toString()
+  )
+  vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest)
+  vaults[indexBefore].addDeposit(depositAmount)
+
+  if (liquidate) {
+    vaults[indexBefore].liquidate()
+  }
+  if (redeem) {
+    vaults[indexBefore].redeem()
+  }
+  vaults[indexBefore].redistribution(vaultTypeAccount)
+
+  if (vaults[indexBefore].denormalizedDebt === 0) {
+    vaults.splice(indexBefore, 1)
+  }
+
+  // Sort it again since we've changed one vault
+  vaults = vaults.sort(sortVaults)
+
+  // Pretty print the list again
+  // console.log('Sorted open vaults with new debt added')
+  // vaults.forEach((vault) => {
+  //   console.log(vault.toString(vaultPublicKey))
+  // })
+
+  // Search for the vaults new position
+  let indexAfter = -1
+  vaults.forEach((vault, index) => {
+    if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+      indexAfter = index
+    }
+  })
+
+  // Print where it moved from / to
+  // console.log('Index Before', indexBefore)
+  // console.log('Index After', indexAfter)
+
+  // Save references to the new left and right
+  if (indexAfter > 0) {
+    newSmallerPublicKey = vaults[indexAfter - 1].publicKey
+  }
+  if (indexAfter < vaults.length - 1 && indexAfter >= 0) {
+    newLargerPublicKey = vaults[indexAfter + 1].publicKey
+  }
+
+  // Print out the new left/right
+  // console.log('oldSmallerPublicKey', oldSmallerPublicKey.toString())
+  // console.log('newSmallerPublicKey', newSmallerPublicKey.toString())
+  // console.log('newLargerPublicKey', newLargerPublicKey.toString())
+
+  return [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey]
+}
+
+// Sort function we can use to sort the vaults
+// Sorted by collateral ratio. If two are the same, newer vault first
+function sortVaults(a: VaultAccount, b: VaultAccount) {
+  const aRatio = a.deposited / a.denormalizedDebt
+  const bRatio = b.deposited / b.denormalizedDebt
+  if (aRatio === bRatio) {
+    return b.vaultNumber - a.vaultNumber
+  }
+  return aRatio - bRatio
+}