refactor: splut out and test calculateStakedPctOfSupply

src/provider.tsx

@@ -11,7 +11,6 @@ import { useAccount, useChainId, useSwitchChain } from 'wagmi';
 import { parseFixed } from '@ethersproject/bignumber';
 import {
   approveStaking,
-  calculateStakedPctOfSupply,
   claim,
   claimAll,
   getDeposit,
@@ -40,6 +39,7 @@ import { erc20abi } from './abis/erc20.js';
 import { AuroraNetwork } from './types/network.js';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { calculateStakedPctOfSupply } from './utils/supply.js';
 
 type StakingProviderProps = {
   network: AuroraNetwork;
@@ -319,11 +319,11 @@ export const StakingProvider = ({
       return;
     }
 
-    const newStakedPct = calculateStakedPctOfSupply(
+    const newStakedPct = calculateStakedPctOfSupply({
       totalStaked,
-      newPrice,
-      newMarketCap,
-    );
+      auroraPrice: newPrice,
+      auroraMarketCap: newMarketCap,
+    });
 
     setStakedPct(newStakedPct);
   }, [

src/utils/staking.ts

@@ -220,19 +220,6 @@ export const getVoteSupply = (voteSchedule: StreamSchedule): BigNumber => {
   return circulatingSupply;
 };
 
-export const calculateStakedPctOfSupply = (
-  totalStaked: BigNumber,
-  auroraPrice: number,
-  auroraMarketCap: number,
-): number => {
-  const circulatingSupply = auroraMarketCap / auroraPrice;
-  // Compounding staked AURORA
-  const stakedAurora = Number(ethers.utils.formatUnits(totalStaked, 18));
-  const pct = (stakedAurora * 100) / circulatingSupply;
-
-  return pct;
-};
-
 export const getIsPaused = async (
   provider: providers.JsonRpcProvider,
   networkConfig: AuroraNetworkConfig,

src/utils/supply.ts

@@ -0,0 +1,20 @@
+import { BigNumber, ethers } from 'ethers';
+
+export const calculateStakedPctOfSupply = ({
+  totalStaked,
+  auroraPrice,
+  auroraMarketCap,
+}: {
+  totalStaked: BigNumber;
+  auroraPrice: number;
+  auroraMarketCap: number;
+}): number => {
+  const circulatingSupply = auroraMarketCap / auroraPrice;
+  const compoundingStakedAurora = Number(
+    ethers.utils.formatUnits(totalStaked, 18),
+  );
+
+  const pct = (compoundingStakedAurora * 100) / circulatingSupply;
+
+  return pct;
+};

tests/utils/apr.test.ts → tests/fixtures/streams-schedule.ts

@@ -1,12 +1,7 @@
 import { BigNumber } from 'ethers';
-import { calculateAprs } from '../../src/utils/apr';
-
-jest.useFakeTimers();
-
-const currentDate = new Date('2024-11-13T12:00:00Z');
 
 // A snapshot of data logged from Aurora Plus
-const streamsSchedule = [
+export const streamsSchedule = [
   {
     scheduleTimes: [
       BigNumber.from('0x6283b870'),
@@ -118,111 +113,3 @@ const streamsSchedule = [
     ],
   },
 ];
-
-const totalStaked = BigNumber.from('50000000000000000000000000');
-const streamDecimals = [18, 18, 18, 18, 18, 18];
-const streamPrices = [
-  0.135344, 0.00007611, 0.00141883, 0.00000127, 0.245603, 0,
-];
-
-describe('APR', () => {
-  beforeEach(() => {
-    jest.setSystemTime(new Date(currentDate));
-  });
-
-  describe('calculateAprs', () => {
-    it('returns the expected APR', async () => {
-      const result = calculateAprs({
-        streamsSchedule,
-        streamPrices,
-        streamDecimals,
-        totalStaked,
-      });
-
-      expect(result).toEqual({
-        aurora: 13.65590130885746,
-        streams: [0, 0, 0, 0, 0],
-        total: 13.65590130885746,
-      });
-    });
-
-    it('modifies the APR according to the total amount staked', async () => {
-      const result = calculateAprs({
-        streamsSchedule,
-        streamPrices,
-        streamDecimals,
-        totalStaked: BigNumber.from('100000000000000000000000000'),
-      });
-
-      expect(result).toEqual({
-        aurora: 6.82795065442873,
-        streams: [0, 0, 0, 0, 0],
-        total: 6.82795065442873,
-      });
-    });
-
-    it('returns an APR of 0 if all rewards are active after the current date', async () => {
-      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
-
-      const result = calculateAprs({
-        streamsSchedule,
-        streamPrices,
-        streamDecimals,
-        totalStaked,
-      });
-
-      expect(result).toEqual({
-        aurora: 0,
-        streams: [0, 0, 0, 0, 0],
-        total: 0,
-      });
-    });
-
-    it('returns an APR of 0 if all rewards were active before the current date', async () => {
-      jest.setSystemTime(new Date('2030-01-01T12:00:00Z'));
-
-      const result = calculateAprs({
-        streamsSchedule,
-        streamPrices,
-        streamDecimals,
-        totalStaked,
-      });
-
-      expect(result).toEqual({
-        aurora: 0,
-        streams: [0, 0, 0, 0, 0],
-        total: 0,
-      });
-    });
-
-    it('returns an APR of 0 if all stream prices are zero', async () => {
-      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
-
-      const result = calculateAprs({
-        streamsSchedule,
-        streamPrices: Array(streamPrices.length).fill(0),
-        streamDecimals,
-        totalStaked,
-      });
-
-      expect(result).toEqual({
-        aurora: 0,
-        streams: [0, 0, 0, 0, 0],
-        total: 0,
-      });
-    });
-
-    it('throws if a stream price is missing', async () => {
-      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
-
-      expect(() => {
-        calculateAprs({
-          streamsSchedule,
-          streamPrices: [],
-          streamDecimals,
-          totalStaked,
-        });
-      }).toThrow('No stream price at position 0');
-    });
-  });
-});

tests/specs/utils/apr.test.ts

@@ -0,0 +1,116 @@
+import { BigNumber } from 'ethers';
+import { calculateAprs } from '../../../src/utils/apr';
+import { streamsSchedule } from '../../fixtures/streams-schedule';
+import { getNumberTo18Decimals } from '../../utils/get-number-to-18-decimals';
+
+jest.useFakeTimers();
+
+const currentDate = new Date('2024-11-13T12:00:00Z');
+
+const totalStaked = getNumberTo18Decimals(50000000);
+const streamDecimals = [18, 18, 18, 18, 18, 18];
+const streamPrices = [
+  0.135344, 0.00007611, 0.00141883, 0.00000127, 0.245603, 0,
+];
+
+describe('APR', () => {
+  beforeEach(() => {
+    jest.setSystemTime(new Date(currentDate));
+  });
+
+  describe('calculateAprs', () => {
+    it('returns the expected APR', async () => {
+      const result = calculateAprs({
+        streamsSchedule,
+        streamPrices,
+        streamDecimals,
+        totalStaked,
+      });
+
+      expect(result).toEqual({
+        aurora: 13.65590130885746,
+        streams: [0, 0, 0, 0, 0],
+        total: 13.65590130885746,
+      });
+    });
+
+    it('modifies the APR according to the total amount staked', async () => {
+      const result = calculateAprs({
+        streamsSchedule,
+        streamPrices,
+        streamDecimals,
+        totalStaked: BigNumber.from('100000000000000000000000000'),
+      });
+
+      expect(result).toEqual({
+        aurora: 6.82795065442873,
+        streams: [0, 0, 0, 0, 0],
+        total: 6.82795065442873,
+      });
+    });
+
+    it('returns an APR of 0 if all rewards are active after the current date', async () => {
+      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
+
+      const result = calculateAprs({
+        streamsSchedule,
+        streamPrices,
+        streamDecimals,
+        totalStaked,
+      });
+
+      expect(result).toEqual({
+        aurora: 0,
+        streams: [0, 0, 0, 0, 0],
+        total: 0,
+      });
+    });
+
+    it('returns an APR of 0 if all rewards were active before the current date', async () => {
+      jest.setSystemTime(new Date('2030-01-01T12:00:00Z'));
+
+      const result = calculateAprs({
+        streamsSchedule,
+        streamPrices,
+        streamDecimals,
+        totalStaked,
+      });
+
+      expect(result).toEqual({
+        aurora: 0,
+        streams: [0, 0, 0, 0, 0],
+        total: 0,
+      });
+    });
+
+    it('returns an APR of 0 if all stream prices are zero', async () => {
+      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
+
+      const result = calculateAprs({
+        streamsSchedule,
+        streamPrices: Array(streamPrices.length).fill(0),
+        streamDecimals,
+        totalStaked,
+      });
+
+      expect(result).toEqual({
+        aurora: 0,
+        streams: [0, 0, 0, 0, 0],
+        total: 0,
+      });
+    });
+
+    it('throws if a stream price is missing', async () => {
+      jest.setSystemTime(new Date('2020-01-01T12:00:00Z'));
+
+      expect(() => {
+        calculateAprs({
+          streamsSchedule,
+          streamPrices: [],
+          streamDecimals,
+          totalStaked,
+        });
+      }).toThrow('No stream price at position 0');
+    });
+  });
+});

tests/specs/utils/supply.test.ts

@@ -0,0 +1,26 @@
+import { calculateStakedPctOfSupply } from '../../../src/utils/supply';
+import { getNumberTo18Decimals } from '../../utils/get-number-to-18-decimals';
+
+describe('APR', () => {
+  describe('calculateStakedPctOfSupply', () => {
+    it('returns the expected result with 1% staked', () => {
+      const result = calculateStakedPctOfSupply({
+        totalStaked: getNumberTo18Decimals(1000),
+        auroraPrice: 0.1,
+        auroraMarketCap: 10000,
+      });
+
+      expect(result).toBe(1);
+    });
+
+    it('returns the expected result with 50% staked', () => {
+      const result = calculateStakedPctOfSupply({
+        totalStaked: getNumberTo18Decimals(50000),
+        auroraPrice: 0.1,
+        auroraMarketCap: 10000,
+      });
+
+      expect(result).toBe(50);
+    });
+  });
+});

tests/utils/get-number-to-18-decimals.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from 'ethers';
+
+export const getNumberTo18Decimals = (number: number) => {
+  return BigNumber.from(`${number}${'0'.repeat(18)}`);
+};