hedge-web3 0.1.27 → 0.1.31

package/src/utils/getLinkedListAccounts.ts

@@ -0,0 +1,157 @@
+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'
+import { Vault } from 'idl/vault'
+export async function getLinkedListAccounts(
+  program: Program<Vault>,
+  provider: Provider,
+  vaultTypeAccountPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  depositAmount: number,
+  loanAmount: number,
+  redeem: boolean,
+  liquidate: boolean,
+  cachedVaults?: VaultAccount[]
+): Promise<[PublicKey, PublicKey, PublicKey, VaultAccount[]]> {
+  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 vaults
+  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)
+    })
+  }
+
+  // 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].updateDebtAndCollateral(vaultTypeAccount)
+  vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest)
+  vaults[indexBefore].addDeposit(depositAmount)
+
+  if (liquidate) {
+    vaults[indexBefore].liquidate()
+  }
+  if (redeem) {
+    vaults[indexBefore].redeem()
+  }
+
+  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, vaults]
+}
+
+// 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
+}