Merge pull request #49 from BirthdayResearch/cuong/removeBurnData2

Add documentation, remove burn data and upgrade ethers

Author: cuongquangnam

.vscode/settings.json

@@ -14,9 +14,8 @@
   ],
   "files.exclude": {
     "**/node_modules": true,
-    "**/.git": true,
+    "**/.git": true
   },
   "prettier.bracketSameLine": false,
-  "prettier.bracketSpacing": true,
-
-}
+  "prettier.bracketSpacing": true
+}

Dockerfile

@@ -6,7 +6,7 @@ RUN apk add --no-cache --virtual .gyp python3 make g++
 
 WORKDIR /staterelayer
 
-COPY package.json hardhat.config.ts .solhint.json ./
+COPY package.json hardhat.config.ts .solhint.json tsconfig.json tsconfig.build.json ./
 COPY contracts ./contracts
 
 RUN npm install 

README.md

@@ -1,13 +1,3 @@
-# Sample Hardhat Project
+# DeFiChain <-> DeFiMetaChain State Relayer
 
-This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
-
-Try running some of the following tasks:
-
-```shell
-npx hardhat help
-npx hardhat test
-REPORT_GAS=true npx hardhat test
-npx hardhat node
-npx hardhat run scripts/deploy.ts
-```
+A project comprising of smart contracts and scripts to port certain information from DeFiChain to DeFiMetaChain

bot/StateRelayerBot.ts

@@ -1,144 +1,70 @@
-// @ts-ignore
 import { getWhaleClient } from '@waveshq/walletkit-bot';
-import { BigNumber } from 'bignumber.js';
 import { ethers } from 'ethers';
 
-import { StateRelayer, StateRelayer__factory } from '../generated';
-import {
-  BurnedInformation,
-  DataStore,
-  MasterNodeData,
-  PairData,
-  StateRelayerHandlerProps,
-  VaultData,
-} from './utils/types';
+import { StateRelayer__factory } from '../generated';
+import { tranformPairData, transformDataMasternode, transformDataVault } from './utils/transformData';
+import { DataStore, MasterNodeData, StateRelayerHandlerProps, VaultData } from './utils/types';
+import { ApiPagedResponse} from '@defichain/whale-api-client'
+import { PoolPairData } from '@defichain/whale-api-client/dist/api/poolpairs'
 
 const DENOMINATION = 'USDT';
-const DECIMALS = 10;
-
-const transformToEthersBigNumber = (str: string, decimals: number): ethers.BigNumber =>
-  ethers.BigNumber.from(
-    new BigNumber(str).multipliedBy(new BigNumber('10').pow(decimals)).integerValue(BigNumber.ROUND_FLOOR).toString(),
-  );
+const PAGESIZE = 50;
 
 export async function handler(props: StateRelayerHandlerProps): Promise<DFCData | undefined> {
   const { urlNetwork, envNetwork, signer, contractAddress } = props;
-  const stateRelayerContract = new ethers.Contract(contractAddress, StateRelayer__factory.abi, signer) as StateRelayer;
+  const stateRelayerContract = StateRelayer__factory.connect(contractAddress, signer);
   const dataStore = {} as DataStore;
-  const burnedData = {} as BurnedInformation;
-  const dataVault = {} as VaultData;
-  const dataMasterNode = {} as MasterNodeData;
   try {
     // TODO: Check if Function should run (blockHeight > 30 from previous)
     // Get Data from OCEAN API
     const client = getWhaleClient(urlNetwork, envNetwork);
     const statsData = await client.stats.get();
-    const rawPoolPairData = await client.poolpairs.list(200);
-    const dexPriceData = await client.poolpairs.listDexPrices(DENOMINATION);
-
-    // sanitize response data
-    const poolPairData = rawPoolPairData.filter((pair: any) => !pair.displaySymbol.includes('/'));
 
-    /* ------------ Data from /dex ----------- */
-    // totalValueLockInPoolPair
-    const totalValueLockInPoolPair = transformToEthersBigNumber(statsData.tvl.dex.toString(), DECIMALS);
-    // total24HVolume
-    const total24HVolume = transformToEthersBigNumber(
-      poolPairData.reduce((acc:any, currPair:any) => acc + (currPair.volume?.h24 ?? 0), 0).toString(),
-      DECIMALS,
-    );
+    let rawPoolPairData : Array<PoolPairData> = [];
+    let pagedPoolPairData: ApiPagedResponse<PoolPairData> = await client.poolpairs.list(PAGESIZE);
+    rawPoolPairData = rawPoolPairData.concat(pagedPoolPairData);
+    while (pagedPoolPairData.hasNext) {
+      pagedPoolPairData = await client.paginate(pagedPoolPairData);
+      rawPoolPairData = rawPoolPairData.concat(pagedPoolPairData);
+    }
+    
+    const dexPriceData = await client.poolpairs.listDexPrices(DENOMINATION);
 
-    // /dex/pair
-    const pair = poolPairData.reduce<PairData>((acc:any, currPair:any) => {
-      let tokenPrice = new BigNumber(0);
-      // price ratio is
-      const priceRatio = currPair.priceRatio.ba;
-      const { symbol } = currPair.tokenB;
-      if (symbol === DENOMINATION || new BigNumber(priceRatio).isZero()) {
-        tokenPrice = new BigNumber(priceRatio);
-      } else {
-        const dexPricePerToken = new BigNumber(dexPriceData.dexPrices[symbol]?.denominationPrice ?? 0);
-        tokenPrice = dexPricePerToken.multipliedBy(currPair.priceRatio.ba);
-      }
-      return {
-        ...acc,
-        [currPair.displaySymbol]: {
-          primaryTokenPrice: transformToEthersBigNumber(tokenPrice.toString(), DECIMALS),
-          volume24H: transformToEthersBigNumber(currPair.volume?.h24.toString() ?? '0', DECIMALS),
-          totalLiquidity: transformToEthersBigNumber(currPair.totalLiquidity.usd ?? '0', DECIMALS),
-          APR: transformToEthersBigNumber(currPair.apr?.total.toString() ?? '0', DECIMALS),
-          firstTokenBalance: transformToEthersBigNumber(currPair.tokenA.reserve, DECIMALS),
-          secondTokenBalance: transformToEthersBigNumber(currPair.tokenB.reserve, DECIMALS),
-          rewards: transformToEthersBigNumber(currPair.apr?.reward.toString() ?? '0', DECIMALS),
-          commissions: transformToEthersBigNumber(currPair.commission, DECIMALS),
-          decimals: DECIMALS,
-        },
-      } as PairData;
-    }, {} as PairData);
-    dataStore.pair = pair;
+    const inputForDexUpdate = tranformPairData(rawPoolPairData, statsData, dexPriceData);
 
     // Data from vaults
-    const totalLoanValue = statsData.loan.value.loan;
-    const totalCollateralValue = statsData.loan.value.collateral;
-    dataVault.noOfVaults = transformToEthersBigNumber(statsData.loan.count.openVaults.toString(), 0);
-    dataVault.totalLoanValue = transformToEthersBigNumber(totalLoanValue.toString(), DECIMALS);
-    dataVault.totalCollateralValue = transformToEthersBigNumber(totalCollateralValue.toString(), DECIMALS);
-    dataVault.totalCollateralizationRatio = transformToEthersBigNumber(
-      ((totalCollateralValue / totalLoanValue) * 100).toFixed(3).toString(),
-      DECIMALS,
-    );
-    dataVault.activeAuctions = transformToEthersBigNumber(statsData.loan.count.openAuctions.toString(), 0);
-    dataVault.decimals = DECIMALS;
+    const dataVault = transformDataVault(statsData);
 
     // Data from Master Nodes
-    dataMasterNode.totalValueLockedInMasterNodes = transformToEthersBigNumber(
-      statsData.tvl.masternodes.toString(),
-      DECIMALS,
-    );
-    dataMasterNode.zeroYearLocked = transformToEthersBigNumber(statsData.masternodes.locked[0].count.toString(), 0);
-    dataMasterNode.fiveYearLocked = transformToEthersBigNumber(statsData.masternodes.locked[2].count.toString(), 0);
-    dataMasterNode.tenYearLocked = transformToEthersBigNumber(statsData.masternodes.locked[1].count.toString(), 0);
-    dataMasterNode.decimals = DECIMALS;
+    const dataMasterNode = transformDataMasternode(statsData);
 
-    // Get Data from all burns in ecosystem
-    burnedData.fee = transformToEthersBigNumber(statsData.burned.fee.toString(), DECIMALS);
-    burnedData.auction = transformToEthersBigNumber(statsData.burned.auction.toString(), DECIMALS);
-    burnedData.payback = transformToEthersBigNumber(statsData.burned.payback.toString(), DECIMALS);
-    burnedData.emission = transformToEthersBigNumber(statsData.burned.emission.toString(), DECIMALS);
-    burnedData.total = transformToEthersBigNumber(statsData.burned.total.toString(), DECIMALS);
-    burnedData.decimals = DECIMALS;
     // Call SC Function to update Data
     // Update Dex information
     const dexInfoTx = await stateRelayerContract.updateDEXInfo(
-      Object.keys(dataStore.pair),
-      Object.values(dataStore.pair),
-      totalValueLockInPoolPair,
-      total24HVolume,
+      inputForDexUpdate.dex,
+      inputForDexUpdate.dexInfo,
+      inputForDexUpdate.totalValueLocked.toString(),
+      inputForDexUpdate.total24HVolume.toString(),
     );
 
     // Update Master Node information
     const masterDataTx = await stateRelayerContract.updateMasterNodeInformation(dataMasterNode);
     // Update Vault general information
     const vaultTx = await stateRelayerContract.updateVaultGeneralInformation(dataVault);
-    // Update Burn information
-    const burnTx = await stateRelayerContract.updateBurnInfo(burnedData);
     if (!props.testGasCost) {
       return {
         dataStore,
         dataVault,
         dataMasterNode,
-        burnedData,
       };
     }
     return {
       dataStore,
       dataVault,
       dataMasterNode,
-      burnedData,
-      dexInfoTxReceipt: await dexInfoTx.wait(),
-      masterDataTxReceipt: await masterDataTx.wait(),
-      vaultTxReceipt: await vaultTx.wait(),
-      burnTxReceipt: await burnTx.wait(),
+      dexInfoTxReceipt: (await dexInfoTx.wait()) || undefined,
+      masterDataTxReceipt: (await masterDataTx.wait()) || undefined,
+      vaultTxReceipt: (await vaultTx.wait()) || undefined,
     };
   } catch (e) {
     console.error((e as Error).message);
@@ -150,9 +76,7 @@ interface DFCData {
   dataStore: DataStore;
   dataVault: VaultData;
   dataMasterNode: MasterNodeData;
-  burnedData: BurnedInformation;
-  dexInfoTxReceipt?: ethers.providers.TransactionReceipt;
-  masterDataTxReceipt?: ethers.providers.TransactionReceipt;
-  vaultTxReceipt?: ethers.providers.TransactionReceipt;
-  burnTxReceipt?: ethers.providers.TransactionReceipt;
+  dexInfoTxReceipt?: ethers.ContractTransactionReceipt;
+  masterDataTxReceipt?: ethers.ContractTransactionReceipt;
+  vaultTxReceipt?: ethers.ContractTransactionReceipt;
 }

bot/test-i9n/StateRelayerBot.unit.ts

@@ -1,14 +1,13 @@
+import { getWhaleClient } from '@waveshq/walletkit-bot';
 import { EnvironmentNetwork } from '@waveshq/walletkit-core';
 import { ethers } from 'ethers';
 
 import { HardhatNetwork, HardhatNetworkContainer, StartedHardhatNetworkContainer } from '../../containers';
 import { StateRelayer, StateRelayer__factory, StateRelayerProxy__factory } from '../../generated';
 import { handler } from '../StateRelayerBot';
+import { tranformPairData } from '../utils/transformData';
 import {
-  expectedBurnedInfo,
-  expectedDexInfo,
   expectedMasterNodeData,
-  expectedPairData,
   expectedVaultData,
   mockedDexPricesData,
   mockedPoolPairData,
@@ -30,8 +29,8 @@ jest.mock('@defichain/whale-api-client', () => ({
 describe('State Relayer Bot Tests', () => {
   let startedHardhatContainer: StartedHardhatNetworkContainer;
   let hardhatNetwork: HardhatNetwork;
-  let admin: ethers.providers.JsonRpcSigner;
-  let bot: ethers.providers.JsonRpcSigner;
+  let admin: ethers.Signer;
+  let bot: ethers.Signer;
   let proxy: StateRelayer;
 
   beforeEach(async () => {
@@ -41,26 +40,26 @@ describe('State Relayer Bot Tests', () => {
       })
       .start();
     hardhatNetwork = await startedHardhatContainer.ready();
-    const stateRelayerImplementation = await hardhatNetwork.contracts.deployContract({
+    const stateRelayerImplementation = await hardhatNetwork?.contracts?.deployContract({
       deploymentName: 'StateRelayerImplementation',
       contractName: 'StateRelayer',
       abi: StateRelayer__factory.abi,
     });
-    admin = hardhatNetwork.getHardhatTestWallet(0).testWalletSigner;
-    bot = hardhatNetwork.getHardhatTestWallet(1).testWalletSigner;
-    const stateRelayerProxy = await hardhatNetwork.contracts.deployContract({
+    admin = (await hardhatNetwork.getHardhatTestWallet(0)).testWalletSigner;
+    bot = (await hardhatNetwork.getHardhatTestWallet(1)).testWalletSigner;
+    const stateRelayerProxy = await hardhatNetwork?.contracts?.deployContract({
       deploymentName: 'StateRelayerProxy',
       contractName: 'StateRelayerProxy',
       abi: StateRelayerProxy__factory.abi,
       deployArgs: [
-        stateRelayerImplementation.address,
+        await stateRelayerImplementation?.getAddress(),
         StateRelayer__factory.createInterface().encodeFunctionData('initialize', [
           await admin.getAddress(),
           await bot.getAddress(),
         ]),
       ],
     });
-    proxy = StateRelayer__factory.connect(stateRelayerProxy.address, bot);
+    proxy = StateRelayer__factory.connect((await stateRelayerProxy?.getAddress()) || '', bot);
   });
 
   afterEach(async () => {
@@ -72,59 +71,61 @@ describe('State Relayer Bot Tests', () => {
       testGasCost: false,
       envNetwork: EnvironmentNetwork.LocalPlayground,
       urlNetwork: '',
-      contractAddress: proxy.address,
+      contractAddress: await proxy.getAddress(),
       signer: bot,
     });
 
+    const client = getWhaleClient('', EnvironmentNetwork.LocalPlayground);
+    const testPoolPairData = await client.poolpairs.list(200);
     if (output !== undefined) {
-      const { dexInfoTxReceipt, masterDataTxReceipt, vaultTxReceipt, burnTxReceipt } = output;
+      const { dexInfoTxReceipt, masterDataTxReceipt, vaultTxReceipt } = output;
       expect(dexInfoTxReceipt).toBeUndefined();
       expect(masterDataTxReceipt).toBeUndefined();
       expect(vaultTxReceipt).toBeUndefined();
-      expect(burnTxReceipt).toBeUndefined();
     }
 
-    const receivedBurnedInfo = await proxy.getBurnedInfo();
-    expect(receivedBurnedInfo[1].fee.toString()).toEqual(expectedBurnedInfo.fee);
-    expect(receivedBurnedInfo[1].auction.toString()).toEqual(expectedBurnedInfo.auction);
-    expect(receivedBurnedInfo[1].payback.toString()).toEqual(expectedBurnedInfo.payback);
-    expect(receivedBurnedInfo[1].emission.toString()).toEqual(expectedBurnedInfo.emission);
-    expect(receivedBurnedInfo[1].total.toString()).toEqual(expectedBurnedInfo.total);
-
     // Checking the /dex/dex-pair info
     const dETH = await proxy.getDexPairInfo('dETH-DFI');
-    expect(dETH[1].primaryTokenPrice.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[0]);
-    expect(dETH[1].volume24H.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[1]);
-    expect(dETH[1].totalLiquidity.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[2]);
-    expect(dETH[1].APR.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[3]);
-    expect(dETH[1].firstTokenBalance.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[4]);
-    expect(dETH[1].secondTokenBalance.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[5]);
-    expect(dETH[1].rewards.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[6]);
-    expect(dETH[1].commissions.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[7]);
-    expect(dETH[1].decimals.toString()).toEqual(Object.values(expectedPairData['dETH-DFI'])[8]);
+    const expectedDexInfo = tranformPairData(testPoolPairData, mockedStatsData, mockedDexPricesData);
+    const lastETHDFIInfo = expectedDexInfo.dexInfo[expectedDexInfo.dex.indexOf('dETH-DFI')];
+    // for sure both two sides have the same type as bigint
+    expect(dETH[1].primaryTokenPrice).toStrictEqual(lastETHDFIInfo.primaryTokenPrice);
+    expect(dETH[1].volume24H).toStrictEqual(lastETHDFIInfo.volume24H);
+    expect(dETH[1].totalLiquidity).toStrictEqual(lastETHDFIInfo.totalLiquidity);
+    expect(dETH[1].APR).toStrictEqual(lastETHDFIInfo.APR);
+    expect(dETH[1].firstTokenBalance).toStrictEqual(lastETHDFIInfo.firstTokenBalance);
+    expect(dETH[1].secondTokenBalance).toStrictEqual(lastETHDFIInfo.secondTokenBalance);
+    expect(dETH[1].rewards).toStrictEqual(lastETHDFIInfo.rewards);
+    expect(dETH[1].commissions).toStrictEqual(lastETHDFIInfo.commissions);
 
     // Checking /dex info
     const dex = await proxy.getDexInfo();
-    expect(dex[2].toString()).toEqual(expectedDexInfo.totalValueLockInPoolPair);
-    expect(dex[1].toString()).toEqual(expectedDexInfo.total24HVolume);
+    expect(dex[2]).toStrictEqual(expectedDexInfo.totalValueLocked);
+    expect(dex[1]).toStrictEqual(expectedDexInfo.total24HVolume);
 
     // Checking MasterNode information
     const receivedMasterNodeData = await proxy.getMasterNodeInfo();
-    expect(receivedMasterNodeData[1].totalValueLockedInMasterNodes.toString()).toEqual(
+    expect(receivedMasterNodeData[1].totalValueLockedInMasterNodes).toStrictEqual(
       expectedMasterNodeData.totalValueLockedInMasterNodes,
     );
-    expect(receivedMasterNodeData[1].zeroYearLocked.toString()).toEqual(expectedMasterNodeData.zeroYearLocked);
-    expect(receivedMasterNodeData[1].fiveYearLocked.toString()).toEqual(expectedMasterNodeData.fiveYearLocked);
-    expect(receivedMasterNodeData[1].tenYearLocked.toString()).toEqual(expectedMasterNodeData.tenYearLocked);
+    expect(receivedMasterNodeData[1].zeroYearLockedNoDecimals).toStrictEqual(
+      expectedMasterNodeData.zeroYearLockedNoDecimals,
+    );
+    expect(receivedMasterNodeData[1].fiveYearLockedNoDecimals).toStrictEqual(
+      expectedMasterNodeData.fiveYearLockedNoDecimals,
+    );
+    expect(receivedMasterNodeData[1].tenYearLockedNoDecimals).toStrictEqual(
+      expectedMasterNodeData.tenYearLockedNoDecimals,
+    );
 
     // Checking VaultInfo
     const receivedVaultData = await proxy.getVaultInfo();
-    expect(receivedVaultData[1].noOfVaults.toString()).toEqual(expectedVaultData.noOfVaults);
-    expect(receivedVaultData[1].totalLoanValue.toString()).toEqual(expectedVaultData.totalLoanValue);
-    expect(receivedVaultData[1].totalCollateralValue.toString()).toEqual(expectedVaultData.totalCollateralValue);
-    expect(receivedVaultData[1].totalCollateralizationRatio.toString()).toEqual(
+    expect(receivedVaultData[1].noOfVaultsNoDecimals).toStrictEqual(expectedVaultData.noOfVaultsNoDecimals);
+    expect(receivedVaultData[1].totalLoanValue).toStrictEqual(expectedVaultData.totalLoanValue);
+    expect(receivedVaultData[1].totalCollateralValue).toStrictEqual(expectedVaultData.totalCollateralValue);
+    expect(receivedVaultData[1].totalCollateralizationRatio).toStrictEqual(
       expectedVaultData.totalCollateralizationRatio,
     );
-    expect(receivedVaultData[1].activeAuctions.toString()).toEqual(expectedVaultData.activeAuctions);
+    expect(receivedVaultData[1].activeAuctionsNoDecimals).toStrictEqual(expectedVaultData.activeAuctionsNoDecimals);
   });
 });