hedge-web3 0.1.50 → 0.2.2

package/src/instructions/withdrawStakingPool.ts

@@ -18,7 +18,8 @@ import {
   getUshMintPublicKey,
   getVaultSystemStatePublicKey,
 } from '../Constants'
-import { Vault } from 'idl/vault'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+import { Vault } from '../idl/vault'
 
 export async function withdrawStakingPool(
   program: Program<Vault>,
@@ -26,7 +27,7 @@ export async function withdrawStakingPool(
   payer: Signer,
   poolPositionPublicKey: PublicKey,
   stakedTokenMintPublicKey: PublicKey,
-  overrideStartTime?: number
+  overrideStartTime?: number,
 ): Promise<PublicKey> {
   const poolPosition = Keypair.generate()
   const transaction = new Transaction().add(
@@ -38,7 +39,8 @@ export async function withdrawStakingPool(
       overrideStartTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
+
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return poolPosition.publicKey
 }
 

package/src/instructions/withdrawVault.ts

@@ -19,7 +19,8 @@ import {
   getHedgeMintPublicKey,
 } from '../Constants'
 import { getLinkedListAccounts } from '../utils/getLinkedListAccounts'
-import { Vault } from 'idl/vault'
+import sendAndConfirmWithDebug from '../utils/sendAndConfirmWithDebug'
+import { Vault } from '../idl/vault'
 
 export async function withdrawVault(
   program: Program<Vault>,
@@ -37,7 +38,6 @@ export async function withdrawVault(
   const history = Keypair.generate()
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
   const vaultAssociatedCollateralAccount = await getOrCreateAssociatedTokenAccount(
     provider.connection,
     payer,
@@ -46,12 +46,12 @@ export async function withdrawVault(
     true
   )
 
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultAccount.vaultType)
   const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
     provider.connection,
     payer,
     vaultTypeAccountInfo.collateralMint,
-    vaultTypeAccountPublicKey,
+    vaultAccount.vaultType,
     true
   )
 
@@ -70,7 +70,7 @@ export async function withdrawVault(
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
     provider,
-    vaultTypeAccountPublicKey,
+    vaultAccount.vaultType,
     vaultPublicKey,
     withdrawAmount * -1,
     0,
@@ -86,7 +86,7 @@ export async function withdrawVault(
       destinationTokenAccount.address,
       vaultPublicKey,
       vaultAssociatedCollateralAccount.address,
-      vaultTypeAccountPublicKey,
+      vaultAccount.vaultType,
       vaultTypeAssociatedTokenAccount.address,
       hedgeStakingPoolPublicKey,
       hedgeStakingPoolAssociatedUshTokenAccount,
@@ -99,7 +99,7 @@ export async function withdrawVault(
       overrideTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history])
+  await sendAndConfirmWithDebug(provider.connection, transaction, [payer, history])
   return vaultPublicKey
 }
 

package/src/state/VaultAccount.ts

@@ -3,6 +3,8 @@ import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
 
 import * as borsh from '@project-serum/borsh'
+import BN from 'bn.js'
+import VaultType from './VaultType'
 
 /**
  * A class that represents an on-chian vault.
@@ -18,10 +20,10 @@ export class VaultAccount {
   pdaSalt: string
 
   /** The deposited collateral of the vault (in SOL Lamports). */
-  deposited = new Decimal(0)
+  deposited: number
 
   /** The outstanding debt of the vault (in USH Lamports). Denormalized to time 0. */
-  denormalizedDebt = new Decimal(0)
+  denormalizedDebt: number
 
   /** The ordered number of when this vault was created. */
   vaultNumber: number
@@ -32,8 +34,8 @@ export class VaultAccount {
   /** Collateral redistribution snapshot' */
   collateralAccumulatorSnapshotBytes = new Decimal(0)
 
-  /** The vault type eg 'SOL-150' */
-  collateralType: string
+  /** The vault type eg '2-SOL-150-0-----' */
+  vaultTypeName: string
 
   /** Current State of the vault ("Open", "Closed", "Liquidated") */
   vaultStatus = ''
@@ -41,29 +43,29 @@ export class VaultAccount {
   /** The public key of the next vault to redeem. */
   nextVaultToRedeem: PublicKey
 
+  /** The public key of the vault type. */
+  vaultType: PublicKey
+
   constructor(vault: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
     this.vaultNumber = vault.vaultNumber?.toNumber()
     this.pdaSalt = vault.pdaSalt
-    if (vault.deposited){
-      this.deposited = new Decimal(vault.deposited.toString())
-    }
-    if (vault.denormalizedDebt){
-      this.denormalizedDebt = new Decimal(vault.denormalizedDebt.toString())
-    }
+    this.deposited = vault.deposited?.toNumber()
+    this.denormalizedDebt = vault.denormalizedDebt?.toNumber()
     if (vault.debtProductSnapshotBytes) {
       this.debtProductSnapshotBytes = DecimalFromU128(vault.debtProductSnapshotBytes.toString())
     }
     if (vault.collateralAccumulatorSnapshotBytes) {
       this.collateralAccumulatorSnapshotBytes = DecimalFromU128(vault.collateralAccumulatorSnapshotBytes.toString())
     }
-    this.collateralType = vault.collateralType
+    this.vaultTypeName = vault.vaultTypeName
     this.nextVaultToRedeem = vault.nextVaultToRedeem
 
     if (vault.vaultStatus) {
       this.vaultStatus = Object.keys(vault.vaultStatus)[0]
     }
+    this.vaultType = vault.vaultType
   }
 
   /**
@@ -82,7 +84,7 @@ export class VaultAccount {
    * @returns collateral value in SOL
    */
   public inSol(): number {
-    return this.deposited.div(LAMPORTS_PER_SOL).toNumber()
+    return this.deposited / LAMPORTS_PER_SOL
   }
 
   /**
@@ -91,7 +93,7 @@ export class VaultAccount {
    * @returns debt value in USH
    */
   public inUsd(): number {
-    return this.denormalizedDebt.div(LAMPORTS_PER_SOL).toNumber()
+    return this.denormalizedDebt / LAMPORTS_PER_SOL
   }
 
   /**
@@ -105,42 +107,45 @@ export class VaultAccount {
       .substring(this.publicKey.toString().length - 6)}`
   }
 
-  public addDebt(newNormalizedDebt: Decimal, vaultTypeCompoundedInterest: Decimal) {
-    const denormalizedNewDebt = newNormalizedDebt.div(vaultTypeCompoundedInterest)
-    this.denormalizedDebt = denormalizedNewDebt.add(new Decimal(this.denormalizedDebt)).floor()
-    // this.denormalizedDebt = parseFloat(this.denormalizedDebt.toFixed(0))
+  public addDebt(additionalDebt: Decimal, vaultTypeAccount: VaultType) {
+    let loanFee = new Decimal(0)
+    if (additionalDebt.isPositive()){
+      loanFee = vaultTypeAccount.loanInitFee.mul(additionalDebt)
+    }
+
+    const totalNormalizedLoan = additionalDebt.add(loanFee)
+    const denormalizedNewDebt = totalNormalizedLoan.div(new Decimal(vaultTypeAccount.cumulativeRate.toString()))
+    this.denormalizedDebt = denormalizedNewDebt.add(new Decimal(this.denormalizedDebt)).floor().toNumber()
   }
+
   public addDeposit(depositAmount: number) {
-    this.deposited = this.deposited.add(depositAmount)
+    this.deposited += depositAmount
   }
 
   public redeem() {
     // TODO - Calculate actual redeem amount and adust correctly
-    this.denormalizedDebt = new Decimal(0)
+    this.denormalizedDebt = 0
     this.vaultStatus = 'initialized'
   }
   public liquidate() {
     // TODO - Calculate actual liquidate amount and adust correctly
-    this.denormalizedDebt = new Decimal(0)
+    this.denormalizedDebt = 0
     this.vaultStatus = 'liquidated'
   }
 
-  public updateDebtAndCollateral(vaultTypeAccuntData: any) {
-    const debtProductCurrent = DecimalFromU128(vaultTypeAccuntData.debtRedistributionProduct)
+  public updateDebtAndCollateral(vaultTypeAccountData: VaultType) {
 
-    const collateralAccumulatorCurrent = DecimalFromU128(vaultTypeAccuntData.collateralRedistributionAccumulator)
-
-    this.denormalizedDebt = debtProductCurrent
+    this.denormalizedDebt = vaultTypeAccountData.debtRedistributionProduct
       .div(this.debtProductSnapshotBytes)
       .mul(new Decimal(this.denormalizedDebt))
+      .toNumber()
 
     const extraCollateralDeposited =
-      this.denormalizedDebt.mul(collateralAccumulatorCurrent.sub(this.collateralAccumulatorSnapshotBytes))
-
-    this.deposited = this.deposited.add(extraCollateralDeposited)
+      this.denormalizedDebt * vaultTypeAccountData.collateralRedistributionAccumulator.sub(this.collateralAccumulatorSnapshotBytes).toNumber()
+    this.deposited += extraCollateralDeposited
 
-    this.collateralAccumulatorSnapshotBytes = collateralAccumulatorCurrent
-    this.debtProductSnapshotBytes = debtProductCurrent
+    this.collateralAccumulatorSnapshotBytes = vaultTypeAccountData.collateralRedistributionAccumulator
+    this.debtProductSnapshotBytes = vaultTypeAccountData.debtRedistributionProduct
   }
 
   public toString(highlight: PublicKey): string {
@@ -149,7 +154,7 @@ export class VaultAccount {
       arrow = ' <----!!'
     }
     let collateralRatio = 'Infinite'
-    if (this.denormalizedDebt.greaterThan(0)) {
+    if (this.denormalizedDebt > 0) {
       collateralRatio = new Decimal(this.deposited).div(new Decimal(this.denormalizedDebt)).toString()
     }
 
@@ -160,7 +165,7 @@ export class VaultAccount {
 
     return `Vault(${this.vaultNumber}): ${this.publicKey.toString().substring(0, 6)}. Debt: ${
       this.denormalizedDebt
-    } Collat: ${this.deposited} Ratio: ${collateralRatio} NextVault: ${nextVault} ${arrow} `
+    } Collat: ${this.deposited} Ratio: ${collateralRatio} ${arrow} `
   }
   /**
    * Creates a VaultAccount from a slice of data

package/src/state/VaultType.ts

@@ -0,0 +1,62 @@
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+
+
+export default class VaultType {
+  publicKey?: PublicKey
+  
+  // On Chain Data
+  name: string
+  collateralMint: PublicKey
+  collateralIndex: number
+  recentPrice: Decimal
+  priceLastUpdatedTimestamp: Decimal
+  collateralHeld: Decimal
+  denormalizedDebtExtended: Decimal
+  debtRedistributionProduct: Decimal
+  collateralRedistributionAccumulator: Decimal
+  minCollateralRatio: Decimal
+  loanInitFee: Decimal
+  minDebtPerVault: Decimal
+  maxDebtExtended: Decimal
+  canBeRedeemed: boolean
+  cumulativeRate: Decimal
+  cumulativeRateLastUpdated: Decimal
+  interestRatePerSecond: Decimal
+  firstVaultToRedeem: PublicKey
+
+  constructor(config: any, publicKey?: PublicKey) {
+    this.publicKey = publicKey
+    this.name = config.collateralType
+    this.loanInitFee = DecimalFromU128(config.loanInitFee)
+    this.minCollateralRatio = DecimalFromU128(config.minCollateralRatio)
+    this.interestRatePerSecond = DecimalFromU128(config.interestRatePerSecond)
+    this.minDebtPerVault = DecimalFromU128(config.minDebtPerVault)
+    this.maxDebtExtended = DecimalFromU128(config.maxDebtExtended)
+    this.canBeRedeemed = config.canBeRedeemed
+    this.collateralMint = config.collateralMint
+    this.firstVaultToRedeem = config.firstVaultToRedeem
+
+    this.recentPrice = DecimalFromU128(config.recentPrice?.toString())
+    this.priceLastUpdatedTimestamp = new Decimal(
+      config.priceLastUpdatedTimestamp.toString()
+    )
+    this.collateralHeld = new Decimal(config.collateralHeld.toString())
+    this.denormalizedDebtExtended = new Decimal(
+      config.denormalizedDebtExtended.toString()
+    )
+    this.debtRedistributionProduct = DecimalFromU128(
+      config.debtRedistributionProduct.toString()
+    )
+    this.collateralRedistributionAccumulator = DecimalFromU128(
+      config.collateralRedistributionAccumulator.toString()
+    )
+    this.cumulativeRate = DecimalFromU128(config.cumulativeRate.toString())
+    this.cumulativeRateLastUpdated = new Decimal(
+      config.cumulativeRateLastUpdated.toString()
+    )
+    this.collateralIndex = config.collateralIndex.toNumber()
+
+  }
+}

package/src/utils/getLinkedListAccounts.ts

@@ -6,10 +6,11 @@ import { getVaultSystemStatePublicKey, getVaultTypeOracleAccountPublicKey, HEDGE
 import { DecimalFromU128 } from '../HedgeDecimal'
 import { VaultAccount } from '../state/VaultAccount'
 import Decimal from 'decimal.js'
-import { Vault } from 'idl/vault'
+import { Vault } from '../idl/vault'
 
 import * as borsh from '@project-serum/borsh'
 import base58 from 'bs58'
+import VaultType from '../state/VaultType'
 
 export async function getLinkedListAccounts(
   program: Program<Vault>,
@@ -22,8 +23,10 @@ export async function getLinkedListAccounts(
   liquidate: boolean,
   cachedVaults?: VaultAccount[]
 ): Promise<[PublicKey, PublicKey, PublicKey, VaultAccount[]]> {
-  console.log('Getting getLinkedListAccounts')
-  const vaultTypeAccount = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeRaw = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultType = new VaultType(vaultTypeRaw, vaultTypeAccountPublicKey)
+
+  const DEBUG = false
 
   // Default for null is the vault itself, so set them all to this vault
   let oldSmallerPublicKey = vaultPublicKey
@@ -31,6 +34,7 @@ export async function getLinkedListAccounts(
   let newLargerPublicKey = vaultPublicKey
 
   const thisVaultData = await program.account.vault.fetch(vaultPublicKey)
+  // const accountInfo =  await program.provider.connection.getAccountInfo(vaultPublicKey)
   const thisVault = new VaultAccount(thisVaultData, vaultPublicKey)
 
   // Load all the vaults
@@ -38,37 +42,23 @@ export async function getLinkedListAccounts(
   if (cachedVaults) {
     vaults = cachedVaults
   } else {
-    // let allVaults = cachedVaults
-    //   ? cachedVaults
-    //   : (await program.account.vault
-    //       .all([
-    //         {
-    //           memcmp: { bytes: vaultTypeAccount.collateralType, offset: 8 + 32 + 8 },
-    //         },
-    //       ])
-    //       .catch((error) => {
-    //         console.log('error', error)
-    //       })) || []
-
-    // // Load them into our account objects
-    // vaults = allVaults.map((vault) => {
-    //   return new VaultAccount(vault.account, vault.publicKey)
-    // })
-    vaults = await getMiniVaults(program, vaultTypeAccount.collateralType)
+    vaults = await getMiniVaults(program, vaultTypeAccountPublicKey)
   }
 
-  console.log('Vault count found:', vaults.length)
-  console.log('First Vault', vaults[0])
+  if (DEBUG) {
+    console.log('Vault count found:', vaults.length)
+    console.log('First Vault', vaults[0])
+  }
 
   // Filter out the accounts that are not open
-  // TODO filter on vault status. Or we enable people to "close out" empty vaults 
+  // TODO filter on vault status. Or we enable people to "close out" empty vaults
   // vaults = _.filter(vaults, (vault) => {
   //   return vault.vaultStatus === 'open'
   // })
 
   // Remove any vaults with no debt or collateral
   vaults = _.filter(vaults, (vault) => {
-    return vault.denormalizedDebt.greaterThan(0) && vault.deposited.greaterThan(0)
+    return vault.denormalizedDebt > 0 && vault.deposited > 0
   })
 
   // Sort them
@@ -87,6 +77,16 @@ export async function getLinkedListAccounts(
     oldSmallerPublicKey = vaults[indexBefore - 1].publicKey
   }
 
+  if (DEBUG) {
+    // Pretty print the list again
+    console.log('Sorted open vaults. Index Before: ', indexBefore)
+    console.log(
+      vaults.map((vault) => {
+        return vault.toString(vaultPublicKey)
+      })
+    )
+  }
+
   // Pretty print all the vaults before the operation
   // console.log('Sorted open vaults BEFORE at index:', indexBefore)
   // let correctOrderBefore = true
@@ -118,9 +118,8 @@ export async function getLinkedListAccounts(
   // Now that we know it's def in the list, iterate the list and update
   // this vault with the operation we're going to apply
   const newNormalizedDebt = new Decimal(loanAmount)
-  const vaultTypeCompoundedInterest = DecimalFromU128(vaultTypeAccount.cumulativeRate.toString())
-  vaults[indexBefore].updateDebtAndCollateral(vaultTypeAccount)
-  vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest)
+  vaults[indexBefore].updateDebtAndCollateral(vaultType)
+  vaults[indexBefore].addDebt(newNormalizedDebt, vaultType)
   vaults[indexBefore].addDeposit(depositAmount)
 
   if (liquidate) {
@@ -130,19 +129,13 @@ export async function getLinkedListAccounts(
     vaults[indexBefore].redeem()
   }
 
-  if (vaults[indexBefore].denormalizedDebt.isZero()) {
+  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 at index: ', indexAfter)
-  // console.log(vaults.map((vault) => {
-  //   return vault.toString(vaultPublicKey)
-  // }))
-
   // Search for the vaults new position
   let indexAfter = -1
   vaults.forEach((vault, index) => {
@@ -151,17 +144,20 @@ export async function getLinkedListAccounts(
     }
   })
 
-  // New list with vault
-  // console.log('New list with vault now at index:', indexAfter)
-  // console.log(
-  //   vaults.map((vault) => {
-  //     return vault.toString(vaultPublicKey)
-  //   })
-  // )
+  if (DEBUG) {
+    // New list with vault
+    console.log('New list with vault now at index:', indexAfter)
+    console.log(
+      vaults.map((vault) => {
+        return vault.toString(vaultPublicKey)
+      })
+    )
+  }
 
-  // Print where it moved from / to
-  console.log('Index Before', indexBefore)
-  console.log('Index After', indexAfter)
+  if (DEBUG) {
+    // Print where it moved from / to
+    console.log('Index After', indexAfter)
+  }
 
   // Save references to the new left and right
   if (indexAfter > 0) {
@@ -171,10 +167,12 @@ export async function getLinkedListAccounts(
     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())
+  if (DEBUG) {
+    // 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, vaults]
 }
@@ -182,32 +180,35 @@ export async function getLinkedListAccounts(
 // 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.floor().div(a.denormalizedDebt.floor())
-  const bRatio = b.deposited.floor().div(b.denormalizedDebt.floor())
-  if (aRatio.equals(bRatio)) {
+  const aRatio = a.deposited / a.denormalizedDebt
+  const bRatio = b.deposited / b.denormalizedDebt
+  if (aRatio === bRatio) {
     return b.vaultNumber - a.vaultNumber
   }
-  if (aRatio.greaterThan(bRatio)){
-    return 1
-  }
-
-  return -1
+  return aRatio - bRatio
 }
 
-async function getMiniVaults(program: Program<Vault>, collateralType: string) {
+async function getMiniVaults(program: Program<Vault>, vaultTypePublicKey: PublicKey) {
   const filters = [
     // Filter for Vault Accounts
     {
       // @ts-ignore
       memcmp: program.account.vault.coder.accounts.memcmp(program.account.vault._idlAccount.name),
     },
-    // Filter for Vaults with this collateral type
+    // Filter for Vaults that are open
     {
       memcmp: {
-        bytes: base58.encode(VaultAccount.getBufferForString(collateralType)),
+        bytes: base58.encode(Buffer.from([1])),
         offset: 8 + 32 + 24,
       },
     },
+    // Filter for Vaults with this collateral type
+    {
+      memcmp: {
+        bytes: vaultTypePublicKey.toString(),
+        offset: 8 + 32 + 24 + 1,
+      },
+    },
   ]
   const allAccounts = await program.provider.connection.getProgramAccounts(HEDGE_PROGRAM_PUBLICKEY, {
     filters: filters,
@@ -219,7 +220,7 @@ async function getMiniVaults(program: Program<Vault>, collateralType: string) {
     },
   })
 
-  return allAccounts.map(vaultData=>{
+  return allAccounts.map((vaultData) => {
     return VaultAccount.FromMiniSlice(vaultData.account.data, vaultData.pubkey)
   })
 }

package/src/utils/sendAndConfirmWithDebug.ts

@@ -0,0 +1,27 @@
+import { Connection, Keypair, Signer, Transaction, TransactionSignature } from '@solana/web3.js'
+
+export default async function sendAndConfirmWithDebug(
+  connection: Connection,
+  transaction: Transaction,
+  signers: Signer[]
+): Promise<TransactionSignature | void> {
+  return connection
+    .sendTransaction(transaction, signers)
+    .then((signature) => {
+      return connection
+        .confirmTransaction(signature)
+        .then((signatureContext) => {
+          return signature
+        })
+        .catch((error) => {
+          console.log('There was an error confirming the transaction', error)
+          console.trace()
+          throw error
+        })
+    })
+    .catch((error) => {
+      console.log('There was an error sending the transaction', error)
+      console.trace()
+      throw error
+    })
+}