hedge-web3 0.1.40 → 0.1.43

package/src/state/VaultAccount.ts

@@ -2,6 +2,8 @@ import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
 
+import * as borsh from '@project-serum/borsh'
+
 /**
  * A class that represents an on-chian vault.
  */
@@ -24,14 +26,17 @@ export class VaultAccount {
   /** The ordered number of when this vault was created. */
   vaultNumber: number
 
-  debtProductSnapshotBytes: Decimal
+  /** Debt redistribution snapshop */
+  debtProductSnapshotBytes = new Decimal(0)
 
-  collateralAccumulatorSnapshotBytes: Decimal
+  /** Collateral redistribution snapshop' */
+  collateralAccumulatorSnapshotBytes = new Decimal(0)
 
+  /** The vault type eg 'SOL-150' */
   collateralType: string
 
   /** Current State of the vautl ("Open", "Closed", "Liquidated") */
-  vaultStatus: string
+  vaultStatus = ''
 
   /** The public key of the next vault to redeem. */
   nextVaultToRedeem: PublicKey
@@ -39,16 +44,22 @@ export class VaultAccount {
   constructor(vault: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
-    this.vaultNumber = vault.vaultNumber.toNumber()
+    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.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.nextVaultToRedeem = vault.nextVaultToRedeem
 
-    this.vaultStatus = Object.keys(vault.vaultStatus)[0]
+    if (vault.vaultStatus) {
+      this.vaultStatus = Object.keys(vault.vaultStatus)[0]
+    }
   }
 
   /**
@@ -119,7 +130,7 @@ export class VaultAccount {
       .div(this.debtProductSnapshotBytes)
       .mul(new Decimal(this.denormalizedDebt))
       .toNumber()
-    
+
     const extraCollateralDeposited =
       this.denormalizedDebt * collateralAccumulatorCurrent.sub(this.collateralAccumulatorSnapshotBytes).toNumber()
     this.deposited += extraCollateralDeposited
@@ -143,8 +154,45 @@ export class VaultAccount {
       nextVault = this.nextVaultToRedeem.toString().substring(0, 6)
     }
 
-    return `Vault(${this.vaultNumber}): ${this.publicKey
-      .toString()
-      .substring(0, 6)}. Debt: ${this.denormalizedDebt} Collat: ${this.deposited} Ratio: ${collateralRatio} NextVault: ${nextVault} ${arrow} `
+    return `Vault(${this.vaultNumber}): ${this.publicKey.toString().substring(0, 6)}. Debt: ${
+      this.denormalizedDebt
+    } Collat: ${this.deposited} Ratio: ${collateralRatio} NextVault: ${nextVault} ${arrow} `
+  }
+  /**
+   * Creates a VaultAccount from a slice of data
+   *
+   * It only contains
+   * - Denormalized Debt
+   * - Deposit
+   * - Vault Number
+   *
+   * This can be used to do off-chain sort with very little data.
+   *
+   * @returns a new VaultAccount
+   */
+  static FromMiniSlice(data: Buffer, pubkey: PublicKey) {
+    const props = [borsh.u64('vaultNumber'), borsh.u64('deposited'), borsh.u64('denormalizedDebt')]
+    const miniVaultLayout = borsh.struct(props, 'minVaultLayout')
+    const decodedData: any = miniVaultLayout.decode(data)
+
+    return new VaultAccount(decodedData, pubkey)
+  }
+
+  /**
+   * Encode a string for doing byte comparison on solana
+   *
+   * @returns Buffer of the encoded string
+   */
+  static getBufferForString(string: string) {
+    const stringLayout = borsh.struct([borsh.str('name')], 'justStringLayout')
+    let buffer = Buffer.alloc(50)
+
+    stringLayout.encode({ name: string }, buffer)
+
+    // Trim empty space at end of buffer
+    while (buffer.at(buffer.length - 1) == 0) {
+      buffer = buffer.slice(0, buffer.length - 1)
+    }
+    return buffer
   }
 }

package/src/utils/Errors.ts

@@ -3,6 +3,7 @@ import { IDL } from '../idl/vault'
 
 export function parseAnchorErrors (error: any): void {
   const idlErrors = parseIdlErrors(IDL)
+  console.log(error)
   const parsedError = ProgramError.parse(error, idlErrors)
   if (parsedError !== null) {
     throw parsedError

package/src/utils/getLinkedListAccounts.ts

@@ -1,12 +1,16 @@
 import { Program, Provider } from '@project-serum/anchor'
 import { PublicKey, Signer } from '@solana/web3.js'
 import _ from 'underscore'
-import { getVaultSystemStatePublicKey, getVaultTypeOracleAccountPublicKey } from '../Constants'
+import { getVaultSystemStatePublicKey, getVaultTypeOracleAccountPublicKey, HEDGE_PROGRAM_PUBLICKEY } from '../Constants'
 
 import { DecimalFromU128 } from '../HedgeDecimal'
 import { VaultAccount } from '../state/VaultAccount'
 import Decimal from 'decimal.js'
 import { Vault } from 'idl/vault'
+
+import * as borsh from '@project-serum/borsh'
+import base58 from 'bs58'
+
 export async function getLinkedListAccounts(
   program: Program<Vault>,
   provider: Provider,
@@ -18,6 +22,7 @@ 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)
 
   // Default for null is the vault itself, so set them all to this vault
@@ -33,32 +38,37 @@ export async function getLinkedListAccounts(
   if (cachedVaults) {
     vaults = cachedVaults
   } else {
-    let allVaults = cachedVaults
-      ? cachedVaults
-      : (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
-    vaults = allVaults.map((vault) => {
-      return new VaultAccount(vault.account, vault.publicKey)
-    })
+    // 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)
   }
 
-  // Filter out the account that are not the same vault type
-  vaults = _.filter(vaults, (vault) => {
-    return vault.collateralType === vaultTypeAccount.collateralType
-  })
+  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 
+  // vaults = _.filter(vaults, (vault) => {
+  //   return vault.vaultStatus === 'open'
+  // })
+
+  // Remove any vaults with no debt or collateral
   vaults = _.filter(vaults, (vault) => {
-    return vault.vaultStatus === 'open'
+    return vault.denormalizedDebt > 0 && vault.deposited > 0
   })
 
   // Sort them
@@ -79,27 +89,30 @@ export async function getLinkedListAccounts(
 
   // Pretty print all the vaults before the operation
   // console.log('Sorted open vaults BEFORE at index:', indexBefore)
-  let correctOrderBefore = true
-  for (let i = 0; i < vaults.length; i++) {
-    if (i < vaults.length - 1) {
-      // Verify i points to i+1
-      if (vaults[i].nextVaultToRedeem.toString() !== vaults[i+1].publicKey.toString()){
-        correctOrderBefore = false
-        console.log("A vault was found OUT OF ORDER!!", vaults[i])
-      }
-    }
-  }
-  if (correctOrderBefore){
-    console.log(`Verfied the on-chain order of vault type:`, vaultTypeAccount.collateralType)
-  } else {
-    throw new Error("On-Chian vaults not in order!");
-  }
+  // let correctOrderBefore = true
+  // for (let i = 0; i < vaults.length; i++) {
+  //   if (i < vaults.length - 1) {
+  //     // Verify i points to i+1
+  //     if (vaults[i].nextVaultToRedeem.toString() !== vaults[i + 1].publicKey.toString()) {
+  //       correctOrderBefore = false
+  //       console.log('A vault was found OUT OF ORDER!!', vaults[i])
+  //     }
+  //   }
+  // }
+  // if (correctOrderBefore) {
+  //   console.log(`Verfied the on-chain order of vault type:`, vaultTypeAccount.collateralType)
+  // } else {
+  //   throw new Error('On-Chian vaults not in order!')
+  // }
 
   // If it wasn't in the list, add it now
   if (indexBefore < 0) {
     // console.log('Was not in the list before. Adding now.')
     vaults.push(thisVault)
     indexBefore = vaults.length - 1
+  } else {
+    // Copy in the vault so we have the full data (needed to run updateDebtAndCollateral)
+    vaults[indexBefore] = thisVault
   }
 
   // Now that we know it's def in the list, iterate the list and update
@@ -147,8 +160,8 @@ export async function getLinkedListAccounts(
   // )
 
   // Print where it moved from / to
-  // console.log('Index Before', indexBefore)
-  // console.log('Index After', indexAfter)
+  console.log('Index Before', indexBefore)
+  console.log('Index After', indexAfter)
 
   // Save references to the new left and right
   if (indexAfter > 0) {
@@ -176,3 +189,33 @@ function sortVaults(a: VaultAccount, b: VaultAccount) {
   }
   return aRatio - bRatio
 }
+
+async function getMiniVaults(program: Program<Vault>, collateralType: string) {
+  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
+    {
+      memcmp: {
+        bytes: base58.encode(VaultAccount.getBufferForString(collateralType)),
+        offset: 8 + 32 + 24,
+      },
+    },
+  ]
+  const allAccounts = await program.provider.connection.getProgramAccounts(HEDGE_PROGRAM_PUBLICKEY, {
+    filters: filters,
+    // Slice the data only to grab the 3 u64's of size 8 bytes each
+    dataSlice: {
+      // See programs/hedge-vault/src/account_data/vault.rs for struct layout
+      offset: 8 + 32,
+      length: 24,
+    },
+  })
+
+  return allAccounts.map(vaultData=>{
+    return VaultAccount.FromMiniSlice(vaultData.account.data, vaultData.pubkey)
+  })
+}