hedge-web3 0.2.7 → 0.2.10

package/src/instructions/createVault.ts

@@ -93,7 +93,7 @@ export async function createVault(
       vaultTypeAccountInfo.collateralMint,
       history.publicKey,
       ushMintPublickey,
-      depositAmount,
+      new BN(depositAmount),
       overrideTime
     )
   )
@@ -187,7 +187,7 @@ export async function buildCreateVaultTransaction(
       vaultTypeAccountInfo.collateralMint,
       history.publicKey,
       ushMintPublickey,
-      depositAmount,
+      new BN(depositAmount),
       overrideTime
     )
   )
@@ -221,7 +221,7 @@ export async function createVaultInstruction(
   collateralMint: PublicKey,
   historyPublicKey: PublicKey,
   ushMintPublickey: PublicKey,
-  depositAmount: number,
+  depositAmount: BN,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()

package/src/instructions/depositLiquidationPool.ts

@@ -24,7 +24,7 @@ export async function depositLiquidationPool(
   program: Program<Vault>,
   provider: Provider,
   payer: Signer,
-  depositAmount: number,
+  depositAmount: BN,
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const ushMintPublickey = await getUshMintPublicKey()
@@ -42,7 +42,7 @@ export async function depositLiquidationPool(
       payer.publicKey,
       payerUshAccount.address,
       poolPosition.publicKey,
-      depositAmount,
+      new BN(depositAmount),
       overrideStartTime
     )
   )
@@ -55,7 +55,7 @@ export async function depositLiquidationPoolInstruction(
   payerPublicKey: PublicKey,
   payerUshAccount: PublicKey,
   poolPositionPublicKey: PublicKey,
-  depositAmount: number,
+  depositAmount: BN,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
   const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey()
@@ -68,7 +68,7 @@ export async function depositLiquidationPoolInstruction(
 
   return await program.methods
     .depositLiquidationPool(
-      new BN(depositAmount),
+      depositAmount,
       new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
     )
     .accounts({

package/src/instructions/depositStakingPool.ts

@@ -30,7 +30,7 @@ export async function depositStakingPool(
       payer.publicKey,
       poolPosition.publicKey,
       mintPublicKey,
-      depositAmount,
+      new BN(depositAmount),
       overrideStartTime
     )
   )
@@ -43,7 +43,7 @@ export async function depositStakingPoolInstruction(
   payerPublicKey: PublicKey,
   poolPositionPublicKey: PublicKey,
   stakedTokenMintPublicKey: PublicKey,
-  depositAmount: number,
+  depositAmount: BN,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
   const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
@@ -53,7 +53,7 @@ export async function depositStakingPoolInstruction(
 
   return await program.methods
     .depositStakingPool(
-      new BN(depositAmount),
+      depositAmount,
       new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
     )
     .accounts({

package/src/instructions/depositVault.ts

@@ -67,11 +67,12 @@ export async function depositVault(
   const signers = [payer, history]
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    depositAmount,
-    0,
+    new BN(depositAmount),
+    new BN(0),
+    new BN(0),
+    new BN(0),
     false,
     false
   )
@@ -111,7 +112,7 @@ export async function depositVault(
       oldSmallerPublicKey,
       newSmallerPublicKey,
       newLargerPublicKey,
-      depositAmount,
+      new BN(depositAmount),
       overrideTime
     )
   )
@@ -146,12 +147,12 @@ export async function depositVaultInstruction(
   oldSmallerPublicKey: PublicKey,
   newSmallerPublicKey: PublicKey,
   newLargerPublicKey: PublicKey,
-  depositAmount: number,
+  depositAmount: BN,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   return await program.methods
     .depositVault(
-      new BN(depositAmount),
+      depositAmount,
       new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
     )
     .accounts({

package/src/instructions/liquidateVault.ts

@@ -87,11 +87,12 @@ export async function liquidateVault(
 
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    0,
-    0,
+    new BN(0),
+    new BN(0),
+    new BN(0),
+    new BN(0),
     false,
     true
   )

package/src/instructions/loanVault.ts

@@ -59,11 +59,12 @@ export async function loanVault(
   )
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    0,
-    loanAmount,
+    new BN(0),
+    new BN(0),
+    new BN(loanAmount),
+    new BN(0),
     false,
     false
   )
@@ -82,7 +83,7 @@ export async function loanVault(
       oldSmallerPublicKey,
       newSmallerPublicKey,
       newLargerPublicKey,
-      loanAmount,
+      new BN(loanAmount),
       overrideTime
     )
   )
@@ -102,7 +103,7 @@ export async function loanVaultInstruction(
   oldSmallerPublicKey: PublicKey,
   newSmallerPublicKey: PublicKey,
   newLargerPublicKey: PublicKey,
-  loanAmount: number,
+  loanAmount: BN,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
@@ -116,7 +117,7 @@ export async function loanVaultInstruction(
 
   return await program.methods
     .loanVault(
-      new BN(loanAmount),
+      loanAmount,
       new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
     )
     .accounts({

package/src/instructions/redeemVault.ts

@@ -67,11 +67,12 @@ export async function redeemVault(
 
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    0,
-    0,
+    new BN(0),
+    new BN(0),
+    new BN(0),
+    new BN(0),
     true,
     false
   )
@@ -91,7 +92,7 @@ export async function redeemVault(
       oldSmallerPublicKey,
       newSmallerPublicKey,
       newLargerPublicKey,
-      redeemAmount,
+      new BN(redeemAmount),
       transactionOverrideTime
     )
   )
@@ -112,7 +113,7 @@ export async function redeemVaultInstruction(
   oldSmallerPublicKey: PublicKey,
   newSmallerPublicKey: PublicKey,
   newLargerPublicKey: PublicKey,
-  redeemAmount: number,
+  redeemAmount: BN,
   transactionOverrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
@@ -125,7 +126,7 @@ export async function redeemVaultInstruction(
   )
   return await program.methods
     .redeemVault(
-      new BN(redeemAmount),
+      redeemAmount,
       new BN(transactionOverrideTime ?? Date.now() / 1000) // override start time
     )
     .accounts({

package/src/instructions/refreshOraclePrice.ts

@@ -44,6 +44,7 @@ export async function refreshOraclePriceInstruction(
     [enc.encode(collateralType), enc.encode('State')],
     HEDGE_PROGRAM_PUBLICKEY
   )
+  const oracleInfo = await program.account.oracleInfoForCollateralType.fetch(oracleInfoAccount)
 
   return await program.methods
     .refreshOraclePrice(
@@ -53,9 +54,9 @@ export async function refreshOraclePriceInstruction(
     .accounts({
       oracleInfoAccount: oracleInfoAccount,
       vaultTypeAccount: vaultTypeAccount,
-      oracleChainlink: chainlinkAccounts[network],
-      oraclePyth: pythAccounts[network],
-      oracleSwitchboard: switchboardAccounts[network],
+      oracleChainlink: oracleInfo.oracleChainlink,
+      oraclePyth: oracleInfo.oraclePyth,
+      oracleSwitchboard: oracleInfo.oracleSwitchboard,
       systemProgram: SystemProgram.programId,
       chainlinkProgram: CHAINLINK_PROGRAM_ID,
     })
@@ -75,12 +76,12 @@ const pythAccounts = {
 }
 const chainlinkAccounts = {
   Testing: SystemProgram.programId,
-  Devnet: new PublicKey('FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'),
+  Devnet: new PublicKey('HgTtcbcmp5BeThax5AU8vg4VwK79qAvAKKFMs8txMLW6'),
   MainnetBeta: SystemProgram.programId, // CHAINLINK NOT ON MAINNET YET
 }
 const switchboardAccounts = {
   Testing: SystemProgram.programId,
   // Devnet: new PublicKey('GvDMxPzN1sCj7L26YDK2HnMRXEQmQ2aemov8YBtPS7vR'),
-  Devnet: new PublicKey('DpoK8Zz69APV9ntjuY9C4LZCxANYMV56M2cbXEdkjxME'),
+  Devnet: new PublicKey('GvDMxPzN1sCj7L26YDK2HnMRXEQmQ2aemov8YBtPS7vR'),
   MainnetBeta: SystemProgram.programId, // Switchboard V2 NOT ON MAINNET YET
 }

package/src/instructions/repayVault.ts

@@ -49,11 +49,12 @@ export async function repayVault(
 
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    0,
-    repayAmount * -1,
+    new BN(0),
+    new BN(0),
+    new BN(0),
+    new BN(Math.abs(repayAmount)),
     false,
     false
   )
@@ -72,7 +73,7 @@ export async function repayVault(
       oldSmallerPublicKey,
       newSmallerPublicKey,
       newLargerPublicKey,
-      repayAmount,
+      new BN(repayAmount),
       overrideTime
     )
   )
@@ -92,7 +93,7 @@ export async function repayVaultInstruction(
   oldSmallerPublicKey: PublicKey,
   newSmallerPublicKey: PublicKey,
   newLargerPublicKey: PublicKey,
-  repayAmount: number,
+  repayAmount: BN,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
@@ -106,7 +107,7 @@ export async function repayVaultInstruction(
 
   return await program.methods
     .repayVault(
-      new BN(repayAmount),
+      repayAmount,
       new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
     )
     .accounts({

package/src/instructions/withdrawVault.ts

@@ -69,11 +69,12 @@ export async function withdrawVault(
 
   const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
     program,
-    provider,
     vaultAccount.vaultType,
     vaultPublicKey,
-    withdrawAmount * -1,
-    0,
+    new BN(0),
+    new BN(Math.abs(withdrawAmount)),
+    new BN(0),
+    new BN(0),
     false,
     false
   )
@@ -95,7 +96,7 @@ export async function withdrawVault(
       oldSmallerPublicKey,
       newSmallerPublicKey,
       newLargerPublicKey,
-      withdrawAmount,
+      new BN(withdrawAmount),
       overrideTime
     )
   )
@@ -119,12 +120,12 @@ export async function withdrawVaultInstruction(
   oldSmallerPublicKey: PublicKey,
   newSmallerPublicKey: PublicKey,
   newLargerPublicKey: PublicKey,
-  withdrawAmount: number,
+  withdrawAmount: BN,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   return await program.methods
     .withdrawVault(
-      new BN(withdrawAmount),
+      withdrawAmount,
       new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
     )
     .accounts({

package/src/state/VaultAccount.ts

@@ -20,10 +20,10 @@ export class VaultAccount {
   pdaSalt: string
 
   /** The deposited collateral of the vault (in SOL Lamports). */
-  deposited: number
+  deposited = new BN(0)
 
   /** The outstanding debt of the vault (in USH Lamports). Denormalized to time 0. */
-  denormalizedDebt: number
+  denormalizedDebt = new BN(0)
 
   /** The ordered number of when this vault was created. */
   vaultNumber = 0
@@ -50,8 +50,10 @@ export class VaultAccount {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
     this.pdaSalt = vault.pdaSalt
-    this.deposited = vault.deposited?.toNumber()
-    this.denormalizedDebt = vault.denormalizedDebt?.toNumber()
+    
+    this.deposited = vault.deposited
+    this.denormalizedDebt = vault.denormalizedDebt
+
     if (vault.vaultNumber) {
       this.vaultNumber = vault.vaultNumber.toNumber()
     }
@@ -80,14 +82,15 @@ export class VaultAccount {
     return publicKey && publicKey.toString() === this.vaultOwner.toString()
   }
 
-  /**
-   * Get the collateral value in SOL
-   *
-   * @returns collateral value in SOL
-   */
-  public inSol(): number {
-    return this.deposited / LAMPORTS_PER_SOL
-  }
+  // /**
+  //  * Get the collateral value in SOL
+  //  *
+  //  * @returns collateral value in SOL
+  //  */
+  // public inSol(): number {
+  // This should not be LAMPORTS_PER_SOL. Should be collateral units like Ray
+  //   return new Decimal(this.deposited.toString()).div(LAMPORTS_PER_SOL).toNumber()
+  // }
 
   /**
    * Get the debt value in USH
@@ -95,7 +98,7 @@ export class VaultAccount {
    * @returns debt value in USH
    */
   public inUsd(): number {
-    return this.denormalizedDebt / LAMPORTS_PER_SOL
+    return new Decimal(this.denormalizedDebt.toString()).div(LAMPORTS_PER_SOL).toNumber()
   }
 
   /**
@@ -109,42 +112,82 @@ export class VaultAccount {
       .substring(this.publicKey.toString().length - 6)}`
   }
 
-  public addDebt(additionalDebt: Decimal, vaultTypeAccount: VaultType) {
-    let loanFee = new Decimal(0)
-    if (additionalDebt.isPositive()){
-      loanFee = vaultTypeAccount.loanInitFee.mul(additionalDebt)
-    }
+  /**
+   * Add additional debt to the vault.
+   *
+   * @param {BN} additionalDebt - Additional normalized debt to add in (USH) lamports.
+   * @param {VaultType} vaultTypeAccount - Vault's vaultType
+   *
+   */
+  public addDebt(additionalDebt: BN, vaultTypeAccount: VaultType) {
+    const additionalDebtAsDecimal = new Decimal(additionalDebt.toString())
+    // Calculate the fee on the loan
+    const loanFee = vaultTypeAccount.loanInitFee.mul(additionalDebtAsDecimal)
 
-    const totalNormalizedLoan = additionalDebt.add(loanFee)
-    const denormalizedNewDebt = totalNormalizedLoan.div(new Decimal(vaultTypeAccount.cumulativeRate.toString()))
-    this.denormalizedDebt = denormalizedNewDebt.add(new Decimal(this.denormalizedDebt)).floor().toNumber()
+    // TODO: There's a chance this needs to be .Floor()
+    const totalNormalizedLoan = additionalDebtAsDecimal.add(loanFee)
+
+    const denormalizedNewDebt = new BN(totalNormalizedLoan.div(vaultTypeAccount.cumulativeRate).floor().toString())
+    this.denormalizedDebt = this.denormalizedDebt.add(denormalizedNewDebt)
   }
 
-  public addDeposit(depositAmount: number) {
-    this.deposited += depositAmount
+  /**
+   * Repay debt on a vault
+   *
+   * @param {BN} repayAmount - Normalized debt to repay in (USH) lamports.
+   * @param {VaultType} vaultTypeAccount - Vault's vaultType
+   *
+   */
+  public repayDebt(repayAmount: BN, vaultTypeAccount: VaultType) {
+    const denormalizedRepayment = new Decimal(repayAmount.toString()).div(vaultTypeAccount.cumulativeRate).floor()
+
+    this.denormalizedDebt = this.denormalizedDebt.sub(new BN(denormalizedRepayment.toString()))
+  }
+
+  /**
+   * Deposit Collateral
+   *
+   * @param {BN} depositAmount - Amount to deposit in (CollateralMint) lamports
+   *
+   */
+  public depositCollateral(depositAmount: BN) {
+    this.deposited = this.deposited.add(depositAmount)
+  }
+  /**
+   * Withdraw Collateral
+   *
+   * @param {BN} withdrawAmount - Amount to withdraw in (CollateralMint) lamports
+   *
+   */
+  public withdrawCollateral(withdrawAmount: BN) {
+    this.deposited = this.deposited.sub(withdrawAmount)
   }
 
   public redeem() {
     // TODO - Calculate actual redeem amount and adust correctly
-    this.denormalizedDebt = 0
+    this.denormalizedDebt = new BN(0)
     this.vaultStatus = 'initialized'
   }
   public liquidate() {
     // TODO - Calculate actual liquidate amount and adust correctly
-    this.denormalizedDebt = 0
+    this.denormalizedDebt = new BN(0)
     this.vaultStatus = 'liquidated'
   }
 
   public updateDebtAndCollateral(vaultTypeAccountData: VaultType) {
-
-    this.denormalizedDebt = vaultTypeAccountData.debtRedistributionProduct
+    this.denormalizedDebt = new BN(
+      vaultTypeAccountData.debtRedistributionProduct
       .div(this.debtProductSnapshotBytes)
-      .mul(new Decimal(this.denormalizedDebt))
-      .toNumber()
+      .mul(new Decimal(this.denormalizedDebt.toString()))
+      .floor()
+      .toString()
+    )
 
     const extraCollateralDeposited =
-      this.denormalizedDebt * vaultTypeAccountData.collateralRedistributionAccumulator.sub(this.collateralAccumulatorSnapshotBytes).toNumber()
-    this.deposited += extraCollateralDeposited
+      new Decimal(this.denormalizedDebt.toString()).mul(
+        vaultTypeAccountData.collateralRedistributionAccumulator.sub(this.collateralAccumulatorSnapshotBytes).toNumber()
+      ).floor()
+    this.deposited = this.deposited.add(new BN(extraCollateralDeposited.toString()))
 
     this.collateralAccumulatorSnapshotBytes = vaultTypeAccountData.collateralRedistributionAccumulator
     this.debtProductSnapshotBytes = vaultTypeAccountData.debtRedistributionProduct
@@ -156,8 +199,8 @@ export class VaultAccount {
       arrow = ' <----!!'
     }
     let collateralRatio = 'Infinite'
-    if (this.denormalizedDebt > 0) {
-      collateralRatio = new Decimal(this.deposited).div(new Decimal(this.denormalizedDebt)).toString()
+    if (this.denormalizedDebt.gt(new BN(0))) {
+      collateralRatio = new Decimal(this.deposited.toString()).div(new Decimal(this.denormalizedDebt.toString())).toString()
     }
 
     let nextVault = 'None'
@@ -165,9 +208,9 @@ export class VaultAccount {
       nextVault = this.nextVaultToRedeem.toString().substring(0, 6)
     }
 
-    return `${this.publicKey.toString().substring(0, 6)}. Debt: ${
-      this.denormalizedDebt
-    } Collat: ${this.deposited} Ratio: ${collateralRatio} ${arrow} `
+    return `${this.publicKey.toString().substring(0, 6)}. Debt: ${this.denormalizedDebt} Collat: ${
+      this.deposited
+    } Ratio: ${collateralRatio} ${arrow} `
   }
   /**
    * Creates a VaultAccount from a slice of data

package/src/utils/getLinkedListAccounts.ts

@@ -1,4 +1,4 @@
-import { Program, Provider } from '@project-serum/anchor'
+import { Program, Provider, BN } from '@project-serum/anchor'
 import { PublicKey, Signer } from '@solana/web3.js'
 import _ from 'underscore'
 import { getVaultSystemStatePublicKey, getVaultTypeOracleAccountPublicKey, HEDGE_PROGRAM_PUBLICKEY } from '../Constants'
@@ -12,13 +12,28 @@ import * as borsh from '@project-serum/borsh'
 import base58 from 'bs58'
 import VaultType from '../state/VaultType'
 
+/**
+ * Get the accounts the left and right for re-inserting in the linked list
+ *
+ * @param {Program<Vault>} program - Anchor program <Vault ILD>
+ * @param {PublicKey} vaultTypeAccountPublicKey - Vault Type Account PublicKey
+ * @param {PublicKey} vaultPublicKey - Vault Account PublicKey
+ * @param {BN} depositAmount - Amount that will be deposited into vault with instruction
+ * @param {BN} withdrawAmount - Amount that will be withdrawn from vault with instruction
+ * @param {BN} loanAmount - Amount that will be deposited into vault with transaction (sans fees)
+ * @param {BN} repayAmount - Amount that will be repaid into vault with transaction
+ * @param {boolean} redeem - True if vault is going to be redeemed fully
+ * @param {boolean} liquidate - True if vault is going to be liquidated fully
+ * @param {VaultAccount[]} cachedVaults - Optional list of cached vaults. Saves a request to the on-chain data.
+ */
 export async function getLinkedListAccounts(
   program: Program<Vault>,
-  provider: Provider,
   vaultTypeAccountPublicKey: PublicKey,
   vaultPublicKey: PublicKey,
-  depositAmount: number,
-  loanAmount: number,
+  depositAmount: BN,
+  withdrawAmount: BN,
+  loanAmount: BN,
+  repayAmount: BN,
   redeem: boolean,
   liquidate: boolean,
   cachedVaults?: VaultAccount[]
@@ -58,7 +73,7 @@ export async function getLinkedListAccounts(
 
   // Remove any vaults with no debt or collateral
   vaults = _.filter(vaults, (vault) => {
-    return vault.denormalizedDebt > 0 && vault.deposited > 0
+    return vault.denormalizedDebt.gt(new BN(0)) && vault.deposited.gt(new BN(0))
   })
 
   // Sort them
@@ -117,10 +132,13 @@ 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)
   vaults[indexBefore].updateDebtAndCollateral(vaultType)
-  vaults[indexBefore].addDebt(newNormalizedDebt, vaultType)
-  vaults[indexBefore].addDeposit(depositAmount)
+
+  vaults[indexBefore].addDebt(loanAmount, vaultType)
+  vaults[indexBefore].repayDebt(repayAmount, vaultType)
+
+  vaults[indexBefore].depositCollateral(depositAmount)
+  vaults[indexBefore].withdrawCollateral(withdrawAmount)
 
   if (liquidate) {
     vaults[indexBefore].liquidate()
@@ -129,7 +147,7 @@ export async function getLinkedListAccounts(
     vaults[indexBefore].redeem()
   }
 
-  if (vaults[indexBefore].denormalizedDebt === 0) {
+  if (vaults[indexBefore].denormalizedDebt.isZero()) {
     vaults.splice(indexBefore, 1)
   }
 
@@ -180,12 +198,12 @@ 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 / a.denormalizedDebt
-  const bRatio = b.deposited / b.denormalizedDebt
-  if (aRatio === bRatio) {
+  const aRatio = new Decimal(a.deposited.toString()).div(new Decimal(a.denormalizedDebt.toString()))
+  const bRatio = new Decimal(b.deposited.toString()).div(new Decimal(b.denormalizedDebt.toString()))
+  if (aRatio.equals(bRatio)) {
     return a.publicKey.toString() > b.publicKey.toString() ? 1 : -1
   }
-  return aRatio - bRatio
+  return aRatio.greaterThan(bRatio) ? 1 : -1
 }
 
 async function getMiniVaults(program: Program<Vault>, vaultTypePublicKey: PublicKey) {