hedge-web3 0.1.27 → 0.1.31

package/src/instructions/setVaultTypeStatus.ts

@@ -0,0 +1,58 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  findVaultAddress,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from '../Constants'
+
+import { v4 as uuidv4 } from 'uuid'
+import { parseAnchorErrors } from '../utils/Errors'
+import { Vault } from 'idl/vault'
+
+export async function setVaultTypeStatus(
+  program: Program<Vault>,
+  provider: Provider,
+  payer: Signer,
+  vaultTypeAccount: PublicKey,
+  deprecated: boolean
+): Promise<PublicKey> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+
+  const transaction = new Transaction().add(
+    await setVaultTypeStatusInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultTypeAccount, deprecated)
+  )
+
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+  return vaultSystemStatePublicKey
+}
+
+export async function setVaultTypeStatusInstruction(
+  program: Program<Vault>,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultTypeAccount: PublicKey,
+  deprecated: boolean
+): Promise<TransactionInstruction> {
+  return await program.methods
+    .setVaultTypeStatus(deprecated)
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultType: vaultTypeAccount,
+    })
+    .instruction()
+}

package/src/instructions/withdrawStakingPool.ts

@@ -1,11 +1,27 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function withdrawStakingPool (
-  program: Program,
+export async function withdrawStakingPool(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   poolPositionPublicKey: PublicKey,
@@ -22,12 +38,12 @@ export async function withdrawStakingPool (
       overrideStartTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return poolPosition.publicKey
 }
 
-export async function withdrawStakingPoolInstruction (
-  program: Program,
+export async function withdrawStakingPoolInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   poolPositionPublicKey: PublicKey,
   stakedTokenMintPublicKey: PublicKey,
@@ -44,28 +60,26 @@ export async function withdrawStakingPoolInstruction (
   const payerAssociatedUshAccount = await findAssociatedTokenAddress(payerPublicKey, ushMintPublickey)
   const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMintPublickey)
 
-  return program.instruction.withdrawStakingPool(
-    new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)), // override current time
-    {
-      accounts: {
-        payer: payerPublicKey,
-        vaultSystemState: vaultSystemStatePublicKey,
-        pool: poolPublickey,
-        poolPosition: poolPositionPublicKey,
-        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
-        poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
-        payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
-        payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
-        payerAssociatedUshAccount: payerAssociatedUshAccount,
-        communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
-        hedgeMint: hedgeMintPublickey,
-        stakedTokenMint: stakedTokenMintPublicKey,
-        ushMint: ushMintPublickey,
-        rent: SYSVAR_RENT_PUBKEY,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .withdrawStakingPool(
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemStatePublicKey,
+      pool: poolPublickey,
+      poolPosition: poolPositionPublicKey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
+      payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
+      payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+      payerAssociatedUshAccount: payerAssociatedUshAccount,
+      communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+      hedgeMint: hedgeMintPublickey,
+      stakedTokenMint: stakedTokenMintPublicKey,
+      ushMint: ushMintPublickey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/withdrawVault.ts

@@ -1,11 +1,28 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { TokenInstructions } from '@project-serum/serum'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import {
+  findAssociatedTokenAddress,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from '../Constants'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import { Vault } from 'idl/vault'
 
-export async function withdrawVault (
-  program: Program,
+export async function withdrawVault(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
@@ -20,19 +37,47 @@ export async function withdrawVault (
   const history = Keypair.generate()
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
-  const vaultTypeAccount = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
-  const vaultAssociatedCollateralAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, TokenInstructions.WRAPPED_SOL_MINT, vaultPublicKey, true)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
+  const vaultAssociatedCollateralAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    TokenInstructions.WRAPPED_SOL_MINT,
+    vaultPublicKey,
+    true
+  )
 
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccount)
-  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccount, true)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    vaultTypeAccountPublicKey,
+    true
+  )
 
-  const destinationTokenAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey)
+  const destinationTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    payer.publicKey
+  )
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
   const hedgeStakingPoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     ushMintPublickey
   )
 
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
+    program,
+    provider,
+    vaultTypeAccountPublicKey,
+    vaultPublicKey,
+    withdrawAmount * -1,
+    0,
+    false,
+    false
+  )
+
   const transaction = new Transaction().add(
     await withdrawVaultInstruction(
       program,
@@ -41,22 +86,25 @@ export async function withdrawVault (
       destinationTokenAccount.address,
       vaultPublicKey,
       vaultAssociatedCollateralAccount.address,
-      vaultTypeAccount,
+      vaultTypeAccountPublicKey,
       vaultTypeAssociatedTokenAccount.address,
       hedgeStakingPoolPublicKey,
       hedgeStakingPoolAssociatedUshTokenAccount,
       ushMintPublickey,
       history.publicKey,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       withdrawAmount,
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }
 
-export async function withdrawVaultInstruction (
-  program: Program,
+export async function withdrawVaultInstruction(
+  program: Program<Vault>,
   vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
   destinationTokenAccount: PublicKey,
@@ -68,28 +116,34 @@ export async function withdrawVaultInstruction (
   hedgeStakingPoolAssociatedUshTokenAccount: PublicKey,
   ushMint: PublicKey,
   historyPublicKey: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   withdrawAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
-  return program.instruction.withdrawVault(
-    new BN(withdrawAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
-        vault: vaultPublickey,
-        vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
-        feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
-        ushMint: ushMint,
-        history: historyPublicKey,
-        vaultOwner: payerPublicKey,
-        destinationTokenAccount: destinationTokenAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .withdrawVault(
+      new BN(withdrawAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      vault: vaultPublickey,
+      vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
+      feePool: hedgeStakingPoolPublicKey,
+      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      ushMint: ushMint,
+      history: historyPublicKey,
+      vaultOwner: payerPublicKey,
+      destinationTokenAccount: destinationTokenAccount,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/state/LiquidationPoolEra.ts

@@ -1,4 +1,3 @@
-
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
 
@@ -13,10 +12,12 @@ export class LiquidationPoolEra {
   public hedgeRewardsAccumulator: Decimal
   public hedgeRewardsTimestamp: number
 
-  constructor (public liquidyPoolEra: any) {
+  constructor(public liquidyPoolEra: any) {
     this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber()
     this.product = DecimalFromU128(liquidyPoolEra.productBytes)
-    this.sum = liquidyPoolEra.sumBytes.map((sumBytes: number) => { return DecimalFromU128(sumBytes) })
+    this.sum = liquidyPoolEra.sumBytes.map((sumBytes: number) => {
+      return DecimalFromU128(sumBytes)
+    })
     this.hedgeRewardsAccumulator = DecimalFromU128(liquidyPoolEra.hedgeRewardsAccumulatorBytes)
     this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber()
   }

package/src/state/LiquidationPosition.ts

@@ -47,31 +47,4 @@ export class LiquidationPosition {
   public getTokensAvailable (era: LiquidationPoolEra, index: number): Decimal {
     return era.sum[index].minus(this.sumSnapshotsEntry[index]).div(this.productSnapshotEntry).mul(new Decimal(this.deposit)).floor()
   }
-
-  // public getHedgeAvailable (): Decimal {
-  //   const LiquidationPoolTotalSupply = 2000000.0 * LAMPORTS_PER_SOL
-  //   const hedgeRewardsSinceLastUpdate = hedgeRewardsDecay(
-  //     LiquidationPoolTotalSupply,
-  //     this.liquidationPoolState.hedgeInitRewardsTimestamp * 1000,
-  //     this.era.hedgeRewardsTimestamp * 1000,
-  //     Date.now(),
-  //     365 * 1000)
-
-  //   if (this.era.totalDeposits === 0) {
-  //     return new Decimal(0)
-  //   }
-
-  //   const rewardsPerToken = this.era.product.mul(new Decimal(hedgeRewardsSinceLastUpdate / this.era.totalDeposits))
-  //   const newAccumulator = rewardsPerToken.add(new Decimal(this.era.hedgeRewardsAccumulator))
-  //   const hedgeAvailable = (newAccumulator.minus(this.hedgeRewardsSnapshot)).mul(new Decimal(this.deposit)).div(new Decimal(this.productSnapshot))
-  //   return hedgeAvailable
-  // }
 }
-
-// function hedgeRewardsDecay (supply: number, birthTime: number, timeIn: number, timeOut: number, halfLifeInDays: number): number {
-//   const timeInOffsetStart = timeIn - birthTime
-//   const timeOutOffsetStart = timeOut - birthTime
-//   const halfLife = -1 * Math.log(2) / (halfLifeInDays * 60 * 60 * 24)
-//   const awardedTokens = supply * (Math.pow(Math.E, halfLife * timeInOffsetStart) - Math.pow(Math.E, halfLife * timeOutOffsetStart))
-//   return awardedTokens
-// }

package/src/state/StakingPool.ts

@@ -1,4 +1,3 @@
-
 import { PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
@@ -15,11 +14,9 @@ export class StakingPool {
   ushFeeAccumulator: Decimal
   collateralFeeAccumulator: [Decimal]
 
-  constructor (public poolInfo: any, publicKey: PublicKey) {
+  constructor(public poolInfo: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.deposits = poolInfo.deposits.toNumber()
-    // this.totalFeesNow = poolInfo.totalFeesNow.toNumber()
-    // this.totalFeesPrevious = poolInfo.totalFeesPrevious.toNumber()
     this.lastTransactionTime = poolInfo.lastTransactionTime.toNumber()
     this.startTime = poolInfo.startTime.toNumber()
     this.halfLifeInDays = poolInfo.halfLifeInDays.toNumber()
@@ -27,8 +24,8 @@ export class StakingPool {
 
     this.hedgeRewardAccumulator = DecimalFromU128(poolInfo.hedgeRewardAccumulator)
     this.ushFeeAccumulator = DecimalFromU128(poolInfo.ushFeeAccumulator)
-    this.collateralFeeAccumulator = poolInfo.collateralFeeAccumulator.map((sum: any) => { return DecimalFromU128(sum) })
-    // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
+    this.collateralFeeAccumulator = poolInfo.collateralFeeAccumulator.map((sum: any) => {
+      return DecimalFromU128(sum)
+    })
   }
-
 }

package/src/state/StakingPoolPosition.ts

@@ -1,4 +1,3 @@
-
 import { PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
@@ -17,7 +16,7 @@ export class StakingPoolPosition {
   public startSolFeeAccumulator: Decimal
   public open: boolean
 
-  constructor (public poolPositionInfo: any, key: PublicKey, stakingPool: StakingPool) {
+  constructor(public poolPositionInfo: any, key: PublicKey, stakingPool: StakingPool) {
     this.publicKey = key
     this.pool = stakingPool
     this.owner = poolPositionInfo.owner
@@ -33,7 +32,7 @@ export class StakingPoolPosition {
     this.open = poolPositionInfo.state.open !== undefined
   }
 
-  public getCurrentUshFeeReward (): Decimal {
+  public getCurrentUshFeeReward(): Decimal {
     return this.pool.ushFeeAccumulator.minus(this.startUshFeeAccumulator).times(new Decimal(this.deposited))
   }
 }

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,9 +33,10 @@ 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()
@@ -49,8 +53,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 +62,7 @@ export class VaultAccount {
    *
    * @returns collateral value in SOL
    */
-  public inSol (): number {
+  public inSol(): number {
     return this.deposited / LAMPORTS_PER_SOL
   }
 
@@ -68,7 +71,7 @@ export class VaultAccount {
    *
    * @returns debt value in USH
    */
-  public inUsd (): number {
+  public inUsd(): number {
     return this.denormalizedDebt / LAMPORTS_PER_SOL
   }
 
@@ -77,7 +80,61 @@ 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 updateDebtAndCollateral(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/state/VaultHistoryEvent.ts

@@ -1,4 +1,3 @@
-
 import { PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
@@ -18,7 +17,7 @@ export class VaultHistoryEvent {
   timestamp: PublicKey
   action: VaultHistoryAction
 
-  constructor (public account: any, publicKey: PublicKey) {
+  constructor(public account: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.actorAccount = account.actorAccount