hedge-web3 0.1.26 → 0.1.29

package/src/instructions/repayVault.ts

@@ -1,9 +1,28 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getVaultTypeAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  getOrCreateAssociatedTokenAccount,
+  TOKEN_PROGRAM_ID,
+} from '@solana/spl-token'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getPoolPublicKeyForMint,
+  getVaultTypeAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
 
-export async function repayVault (
+export async function repayVault(
   program: Program,
   provider: Provider,
   payer: Signer,
@@ -14,13 +33,40 @@ export async function repayVault (
   const ushMintPublickey = await getUshMintPublicKey()
 
   // Prep the user to get USH back out at some point
-  const payerUshAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  const payerUshAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
 
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
-  const vaultTypeAccount = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
-  const vaultTypeAssociatedTokenAccount = await findAssociatedTokenAddress(vaultTypeAccountPublicKey, vaultTypeAccount.collateralMint)
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, vaultTypeAccount.collateralMint)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    vaultAccount.collateralType
+  )
+  const vaultTypeAccount = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  )
+  const vaultTypeAssociatedTokenAccount = await findAssociatedTokenAddress(
+    vaultTypeAccountPublicKey,
+    vaultTypeAccount.collateralMint
+  )
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
+    vaultPublicKey,
+    vaultTypeAccount.collateralMint
+  )
+
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] =
+    await getLinkedListAccounts(
+      program,
+      provider,
+      vaultTypeAccountPublicKey,
+      vaultPublicKey,
+      0,
+      repayAmount * -1,
+      false,
+      false
+    )
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -33,15 +79,23 @@ export async function repayVault (
       history.publicKey,
       vaultTypeAccountPublicKey,
       vaultTypeAssociatedTokenAccount,
+      oldSmallerPublicKey,
+      newSmallerPublicKey,
+      newLargerPublicKey,
       repayAmount,
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  await sendAndConfirmTransaction(
+    provider.connection,
+    transaction,
+    [payer, history],
+    provider.opts
+  )
   return vaultPublicKey
 }
 
-export async function repayVaultInstruction (
+export async function repayVaultInstruction(
   program: Program,
   payerPublicKey: PublicKey,
   ownerUshAccount: PublicKey,
@@ -50,17 +104,23 @@ export async function repayVaultInstruction (
   historyPublicKey: PublicKey,
   vaultTypeAccount: PublicKey,
   vaultTypeAssociatedTokenAccount: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   repayAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
   const hedgeMintPublickey = await getHedgeMintPublicKey()
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
-  const hedgeStakingPoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    hedgeMintPublickey
   )
+  const hedgeStakingPoolAssociatedUshTokenAccount =
+    await findAssociatedTokenAddress(
+      hedgeStakingPoolPublicKey,
+      ushMintPublickey
+    )
 
   return program.instruction.repayVault(
     new BN(repayAmount),
@@ -74,13 +134,18 @@ export async function repayVaultInstruction (
         vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+        feePoolAssociatedUshTokenAccount:
+          hedgeStakingPoolAssociatedUshTokenAccount,
         ushMint: ushMintPublickey,
         vaultOwner: payerPublicKey,
+        oldSmallerVaultInfo: oldSmallerPublicKey,
+        newSmallerVaultInfo: newSmallerPublicKey,
+        newLargerVaultInfo: newLargerPublicKey,
         ownerUshAccount: ownerUshAccount,
         tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
+        systemProgram: SystemProgram.programId,
       },
-      signers: []
-    })
+      signers: [],
+    }
+  )
 }

package/src/instructions/setVaultTypeStatus.ts

@@ -0,0 +1,50 @@
+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'
+
+export async function setVaultTypeStatus (
+  program: Program,
+  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], provider?.opts).catch(parseAnchorErrors)
+  return vaultSystemStatePublicKey
+}
+
+export async function setVaultTypeStatusInstruction(
+  program: Program,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultTypeAccount: PublicKey,
+  deprecated: boolean
+): Promise<TransactionInstruction> {
+  const ix = program.instruction.setVaultTypeStatus(
+    deprecated,
+    {
+      accounts: {
+        payer: payerPublicKey,
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultType: vaultTypeAccount,
+      },
+      signers: []
+    })
+  return ix
+}

package/src/instructions/withdrawVault.ts

@@ -1,10 +1,29 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
-import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+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'
 
-export async function withdrawVault (
+export async function withdrawVault(
   program: Program,
   provider: Provider,
   payer: Signer,
@@ -15,23 +34,66 @@ export async function withdrawVault (
   const ushMintPublickey = await getUshMintPublicKey()
 
   // Prep the user to get USH back out at some point
-  await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
 
   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 [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
-  const hedgeStakingPoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
+  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(
@@ -41,21 +103,29 @@ 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],
+    provider.opts
+  )
   return vaultPublicKey
 }
 
-export async function withdrawVaultInstruction (
+export async function withdrawVaultInstruction(
   program: Program,
   vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
@@ -68,6 +138,9 @@ export async function withdrawVaultInstruction (
   hedgeStakingPoolAssociatedUshTokenAccount: PublicKey,
   ushMint: PublicKey,
   historyPublicKey: PublicKey,
+  oldSmallerPublicKey: PublicKey,
+  newSmallerPublicKey: PublicKey,
+  newLargerPublicKey: PublicKey,
   withdrawAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
@@ -82,14 +155,19 @@ export async function withdrawVaultInstruction (
         vault: vaultPublickey,
         vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
         feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+        feePoolAssociatedUshTokenAccount:
+          hedgeStakingPoolAssociatedUshTokenAccount,
         ushMint: ushMint,
         history: historyPublicKey,
         vaultOwner: payerPublicKey,
         destinationTokenAccount: destinationTokenAccount,
+        oldSmallerVaultInfo: oldSmallerPublicKey,
+        newSmallerVaultInfo: newSmallerPublicKey,
+        newLargerVaultInfo: newLargerPublicKey,
         tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
+        systemProgram: SystemProgram.programId,
       },
-      signers: []
-    })
+      signers: [],
+    }
+  )
 }

package/src/state/StakingPool.ts

@@ -31,8 +31,4 @@ export class StakingPool {
     // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
   }
 
-//   updateFeeAccumulator () {
-//     this.feeAccumulator = (this.totalFeesNow - this.totalFeesPrevious) / this.deposits
-//     this.totalFeesPrevious = this.totalFeesNow
-//   }
 }

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/Errors.ts

@@ -1,8 +1,8 @@
 import { parseIdlErrors, ProgramError } from '@project-serum/anchor'
-import { vaultIdl } from '../idl/idl'
+import { IDL } from '../idl/vault'
 
 export function parseAnchorErrors (error: any): void {
-  const idlErrors = parseIdlErrors(vaultIdl)
+  const idlErrors = parseIdlErrors(IDL)
   const parsedError = ProgramError.parse(error, idlErrors)
   if (parsedError !== null) {
     throw parsedError