add route test framework

2020-11-09 14:26:38 +08:00
parent 1a0d3990fc
commit d965ce1409
15 changed files with 3342 additions and 10905 deletions
--- a/test/Route/Route.test.ts
+++ b/test/Route/Route.test.ts
@@ -0,0 +1,171 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+// import * as assert from 'assert';
+
+import BigNumber from 'bignumber.js';
+import { DODOContext, getDODOContext } from '../utils-v1/Context';
+import { decimalStr,MAX_UINT256 } from '../utils-v1/Converter';
+import { logGas } from '../utils-v1/Log';
+
+let lp: string;
+let trader: string;
+
+async function init(ctx: DODOContext): Promise<void> {
+  await ctx.setOraclePrice(decimalStr("100"));
+
+  lp = ctx.spareAccounts[0];
+  trader = ctx.spareAccounts[1];
+  await ctx.approveDODO(lp);
+  await ctx.approveDODO(trader);
+
+  await ctx.mintTestToken(lp, decimalStr("10"), decimalStr("1000"));
+  await ctx.mintTestToken(trader, decimalStr("10"), decimalStr("1000"));
+
+  await ctx.DODO.methods
+    .depositBaseTo(lp, decimalStr("10"))
+    .send(ctx.sendParam(lp));
+  await ctx.DODO.methods
+    .depositQuoteTo(lp, decimalStr("1000"))
+    .send(ctx.sendParam(lp));
+
+}
+
+
+async function calcRoute(ctx: DODOContext) {
+  let fromTokenAmount = decimalStr("1");
+  //路径
+  let routes = [
+    {
+      address: ctx.BASE.options.address,
+      decimals: 18
+    },
+    {
+      address: ctx.QUOTE.options.address,
+      decimals: 18
+    }
+  ]
+  
+  //路径上交易对
+  let pairs = [
+    {
+      pair: ctx.DODO.options.address,
+      base: ctx.BASE.options.address
+    }
+  ]
+  let callPairs: string[] = []
+  let datas: string = ""
+  let starts: number[] = []
+  let gAndV: number[] = []
+  let swapAmount = fromTokenAmount
+  for (let i = 0; i < pairs.length; i++) {
+    let curPair = pairs[i]
+    callPairs.push(curPair.pair)
+    //TODO: hardcode
+    let curContact =ctx.DODO;
+    let curData = ''
+    if (curPair.base === routes[i].address) {
+      curData = await curContact.methods.sellBaseToken(swapAmount, 0, []).encodeABI()
+      swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
+    } else {
+      curData = await curContact.methods.buyBaseToken(swapAmount, 0, []).encodABI()
+      swapAmount = await curContact.methods.queryBuyBaseToken(swapAmount).call();
+    }
+    starts.push(datas.length)
+    gAndV.push(0)
+    datas += curData
+  }
+
+  let toAmount  = new BigNumber(swapAmount).multipliedBy(0.99).toFixed(0, BigNumber.ROUND_DOWN)
+
+  return ctx.SmartSwap.methods.dodoSwap(
+    ctx.BASE.options.address,
+    ctx.QUOTE.options.address,
+    fromTokenAmount,
+    toAmount,
+    callPairs,
+    datas,
+    starts,
+    gAndV
+  )
+}
+
+describe("Trader", () => {
+  let snapshotId: string;
+  let ctx: DODOContext;
+
+  before(async () => {
+    ctx = await getDODOContext();
+    await init(ctx);
+  });
+
+  beforeEach(async () => {
+    snapshotId = await ctx.EVM.snapshot();
+  });
+
+  afterEach(async () => {
+    await ctx.EVM.reset(snapshotId);
+  });
+
+  describe("hit currently pair", () => {
+    it("base to quote", async () => {
+      var beforeBalance = await ctx.BASE.methods.balanceOf(trader).call()
+      // await ctx.BASE.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
+      console.log("beforeBalance",beforeBalance)
+      await logGas(await calcRoute(ctx), ctx.sendParam(trader), "buy token")
+      var afterBalance = await ctx.BASE.methods.balanceOf(trader).call()
+      console.log("afterBalance",afterBalance)
+      // // trader balances
+      // assert.equal(
+      //   await ctx.BASE.methods.balanceOf(trader).call(),
+      //   decimalStr("11")
+      // );
+      // assert.equal(
+      //   await ctx.QUOTE.methods.balanceOf(trader).call(),
+      //   "898581839502056240973"
+      // );
+    });
+  });
+
+
+  // describe("Revert cases", () => {
+  //   it("price limit", async () => {
+  //     await assert.rejects(
+  //       ctx.DODO.methods
+  //         .buyBaseToken(decimalStr("1"), decimalStr("100"), "0x")
+  //         .send(ctx.sendParam(trader)),
+  //       /BUY_BASE_COST_TOO_MUCH/
+  //     );
+  //     await assert.rejects(
+  //       ctx.DODO.methods
+  //         .sellBaseToken(decimalStr("1"), decimalStr("100"), "0x")
+  //         .send(ctx.sendParam(trader)),
+  //       /SELL_BASE_RECEIVE_NOT_ENOUGH/
+  //     );
+  //   });
+
+  //   it("base balance limit", async () => {
+  //     await assert.rejects(
+  //       ctx.DODO.methods
+  //         .buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x")
+  //         .send(ctx.sendParam(trader)),
+  //       /DODO_BASE_BALANCE_NOT_ENOUGH/
+  //     );
+
+  //     await ctx.DODO.methods
+  //       .buyBaseToken(decimalStr("1"), decimalStr("200"), "0x")
+  //       .send(ctx.sendParam(trader));
+
+  //     await assert.rejects(
+  //       ctx.DODO.methods
+  //         .buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x")
+  //         .send(ctx.sendParam(trader)),
+  //       /DODO_BASE_BALANCE_NOT_ENOUGH/
+  //     );
+  //   });
+  // });
+});
--- a/test/utils-v1/Context.ts
+++ b/test/utils-v1/Context.ts
@@ -0,0 +1,195 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+import BigNumber from 'bignumber.js';
+import Web3 from 'web3';
+import { Contract } from 'web3-eth-contract';
+
+import * as contracts from './Contracts';
+import { decimalStr, gweiStr, MAX_UINT256 } from './Converter';
+import { EVM, getDefaultWeb3 } from './EVM';
+import * as log from './Log';
+
+BigNumber.config({
+  EXPONENTIAL_AT: 1000,
+  DECIMAL_PLACES: 80,
+});
+
+export interface DODOContextInitConfig {
+  lpFeeRate: string;
+  mtFeeRate: string;
+  k: string;
+  gasPriceLimit: string;
+}
+
+/*
+  price curve when k=0.1
+  +──────────────────────+───────────────+
+  | purchase percentage  | avg slippage  |
+  +──────────────────────+───────────────+
+  | 1%                   | 0.1%         |
+  | 5%                   | 0.5%         |
+  | 10%                  | 1.1%         |
+  | 20%                  | 2.5%         |
+  | 50%                  | 10%          |
+  | 70%                  | 23.3%        |
+  +──────────────────────+───────────────+
+*/
+export let DefaultDODOContextInitConfig = {
+  lpFeeRate: decimalStr("0.002"),
+  mtFeeRate: decimalStr("0.001"),
+  k: decimalStr("0.1"),
+  gasPriceLimit: gweiStr("100"),
+};
+
+export class DODOContext {
+  EVM: EVM;
+  Web3: Web3;
+  DODO: Contract;
+  DODOZoo: Contract;
+  BASE: Contract;
+  BaseCapital: Contract;
+  QUOTE: Contract;
+  QuoteCapital: Contract;
+  ORACLE: Contract;
+  SmartSwap: Contract;
+  SmartApprove: Contract;
+  Deployer: string;
+  Supervisor: string;
+  Maintainer: string;
+  spareAccounts: string[];
+
+  constructor() {}
+
+  async init(config: DODOContextInitConfig) {
+    this.EVM = new EVM();
+    this.Web3 = getDefaultWeb3();
+    var cloneFactory = await contracts.newContract(
+      contracts.CLONE_FACTORY_CONTRACT_NAME
+    );
+
+    this.BASE = await contracts.newContract(
+      contracts.TEST_ERC20_CONTRACT_NAME,
+      ["TestBase", 18]
+    );
+    this.QUOTE = await contracts.newContract(
+      contracts.TEST_ERC20_CONTRACT_NAME,
+      ["TestQuote", 18]
+    );
+    this.ORACLE = await contracts.newContract(
+      contracts.NAIVE_ORACLE_CONTRACT_NAME
+    );
+
+    const allAccounts = await this.Web3.eth.getAccounts();
+    this.Deployer = allAccounts[0];
+    this.Supervisor = allAccounts[1];
+    this.Maintainer = allAccounts[2];
+    this.spareAccounts = allAccounts.slice(3, 10);
+
+    var DODOTemplate = await contracts.newContract(
+      contracts.DODO_CONTRACT_NAME
+    );
+    this.DODOZoo = await contracts.newContract(
+      contracts.DODO_ZOO_CONTRACT_NAME,
+      [
+        DODOTemplate.options.address,
+        cloneFactory.options.address,
+        this.Supervisor,
+      ]
+    );
+
+    await this.DODOZoo.methods
+      .breedDODO(
+        this.Maintainer,
+        this.BASE.options.address,
+        this.QUOTE.options.address,
+        this.ORACLE.options.address,
+        config.lpFeeRate,
+        config.mtFeeRate,
+        config.k,
+        config.gasPriceLimit
+      )
+      .send(this.sendParam(this.Deployer));
+
+    this.DODO = contracts.getContractWithAddress(
+      contracts.DODO_CONTRACT_NAME,
+      await this.DODOZoo.methods
+        .getDODO(this.BASE.options.address, this.QUOTE.options.address)
+        .call()
+    );
+    await this.DODO.methods
+      .enableBaseDeposit()
+      .send(this.sendParam(this.Deployer));
+    await this.DODO.methods
+      .enableQuoteDeposit()
+      .send(this.sendParam(this.Deployer));
+    await this.DODO.methods.enableTrading().send(this.sendParam(this.Deployer));
+
+    this.BaseCapital = contracts.getContractWithAddress(
+      contracts.DODO_LP_TOKEN_CONTRACT_NAME,
+      await this.DODO.methods._BASE_CAPITAL_TOKEN_().call()
+    );
+    this.QuoteCapital = contracts.getContractWithAddress(
+      contracts.DODO_LP_TOKEN_CONTRACT_NAME,
+      await this.DODO.methods._QUOTE_CAPITAL_TOKEN_().call()
+    );
+
+    /*v1.5*/
+    this.SmartApprove = await contracts.newContract(
+      contracts.SMART_APPROVE
+    );
+
+    this.SmartSwap = await contracts.newContract(
+      contracts.SMART_SWAP,
+      [this.SmartApprove.options.address]
+    );
+
+    await this.SmartApprove.methods.setSmartSwap(this.SmartSwap.options.address).send(this.sendParam(this.Deployer));
+    /*****/
+
+    console.log(log.blueText("[Init dodo context]"));
+  }
+
+  sendParam(sender, value = "0") {
+    return {
+      from: sender,
+      gas: process.env["COVERAGE"] ? 10000000000 : 7000000,
+      gasPrice: process.env.GAS_PRICE,
+      value: decimalStr(value),
+    };
+  }
+
+  async setOraclePrice(price: string) {
+    await this.ORACLE.methods
+      .setPrice(price)
+      .send(this.sendParam(this.Deployer));
+  }
+
+  async mintTestToken(to: string, base: string, quote: string) {
+    await this.BASE.methods.mint(to, base).send(this.sendParam(this.Deployer));
+    await this.QUOTE.methods
+      .mint(to, quote)
+      .send(this.sendParam(this.Deployer));
+  }
+
+  async approveDODO(account: string) {
+    await this.BASE.methods
+      .approve(this.DODO.options.address, MAX_UINT256)
+      .send(this.sendParam(account));
+    await this.QUOTE.methods
+      .approve(this.DODO.options.address, MAX_UINT256)
+      .send(this.sendParam(account));
+  }
+}
+
+export async function getDODOContext(
+  config: DODOContextInitConfig = DefaultDODOContextInitConfig
+): Promise<DODOContext> {
+  var context = new DODOContext();
+  await context.init(config);
+  return context;
+}
--- a/test/utils-v1/Contracts.ts
+++ b/test/utils-v1/Contracts.ts
@@ -0,0 +1,118 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+var jsonPath: string = "../../build-v1/contracts/"
+/*v1.5*/
+var jsonPath2: string = "../../build/contracts/"
+/******/
+if (process.env["COVERAGE"]) {
+  console.log("[Coverage mode]")
+  jsonPath = "../../.coverage_artifacts/contracts/"
+}
+
+const CloneFactory = require(`${jsonPath}CloneFactory.json`)
+const DODO = require(`${jsonPath}DODO.json`)
+const DODOZoo = require(`${jsonPath}DODOZoo.json`)
+const DODOEthProxy = require(`${jsonPath}DODOEthProxy.json`)
+const WETH = require(`${jsonPath}WETH9.json`)
+const TestERC20 = require(`${jsonPath}TestERC20.json`)
+const NaiveOracle = require(`${jsonPath}NaiveOracle.json`)
+const DODOLpToken = require(`${jsonPath}DODOLpToken.json`)
+const Uniswap = require(`${jsonPath}UniswapV2Pair.json`)
+const UniswapArbitrageur = require(`${jsonPath}UniswapArbitrageur.json`)
+const DODOToken = require(`${jsonPath}DODOToken.json`)
+const DODOMine = require(`${jsonPath}DODOMine.json`)
+const DODOMineReader = require(`${jsonPath}DODOMineReader.json`)
+const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`)
+/*v1.5*/
+const SmartSwap = require(`${jsonPath2}SmartSwap.json`)
+const SmartApprove = require(`${jsonPath2}SmartApprove.json`)
+/******/
+
+import { getDefaultWeb3 } from './EVM';
+import { Contract } from 'web3-eth-contract';
+
+export const CLONE_FACTORY_CONTRACT_NAME = "CloneFactory"
+export const DODO_CONTRACT_NAME = "DODO"
+export const TEST_ERC20_CONTRACT_NAME = "TestERC20"
+export const NAIVE_ORACLE_CONTRACT_NAME = "NaiveOracle"
+export const DODO_LP_TOKEN_CONTRACT_NAME = "DODOLpToken"
+export const DODO_ZOO_CONTRACT_NAME = "DOOZoo"
+export const DODO_WILD_CONTRACT_NAME = "DOOWild"
+export const DODO_ETH_PROXY_CONTRACT_NAME = "DODOEthProxy"
+export const WETH_CONTRACT_NAME = "WETH"
+export const UNISWAP_CONTRACT_NAME = "Uniswap"
+export const UNISWAP_ARBITRAGEUR_CONTRACT_NAME = "UniswapArbitrageur"
+export const DODO_TOKEN_CONTRACT_NAME = "DODOToken"
+export const LOCKED_TOKEN_VAULT_CONTRACT_NAME = "LockedTokenVault"
+export const DODO_MINE_NAME = "DODOMine"
+export const DODO_MINE_READER_NAME = "DODOMineReader"
+/*v1.5*/
+export const SMART_SWAP = "SmartSwap"
+export const SMART_APPROVE = "SmartApprove"
+/******/
+
+var contractMap: { [name: string]: any } = {}
+contractMap[CLONE_FACTORY_CONTRACT_NAME] = CloneFactory
+contractMap[DODO_CONTRACT_NAME] = DODO
+contractMap[TEST_ERC20_CONTRACT_NAME] = TestERC20
+contractMap[NAIVE_ORACLE_CONTRACT_NAME] = NaiveOracle
+contractMap[DODO_LP_TOKEN_CONTRACT_NAME] = DODOLpToken
+contractMap[DODO_ZOO_CONTRACT_NAME] = DODOZoo
+contractMap[DODO_ETH_PROXY_CONTRACT_NAME] = DODOEthProxy
+contractMap[WETH_CONTRACT_NAME] = WETH
+contractMap[UNISWAP_CONTRACT_NAME] = Uniswap
+contractMap[UNISWAP_ARBITRAGEUR_CONTRACT_NAME] = UniswapArbitrageur
+contractMap[DODO_TOKEN_CONTRACT_NAME] = DODOToken
+contractMap[LOCKED_TOKEN_VAULT_CONTRACT_NAME] = LockedTokenVault
+contractMap[DODO_MINE_NAME] = DODOMine
+contractMap[DODO_MINE_READER_NAME] = DODOMineReader
+/*v1.5*/
+contractMap[SMART_SWAP] = SmartSwap
+contractMap[SMART_APPROVE] = SmartApprove
+/******/
+
+interface ContractJson {
+  abi: any;
+  networks: { [network: number]: any };
+  byteCode: string;
+}
+
+export function getContractJSON(contractName: string): ContractJson {
+  var info = contractMap[contractName]
+  return {
+    abi: info.abi,
+    networks: info.networks,
+    byteCode: info.bytecode
+  }
+}
+
+export function getContractWithAddress(contractName: string, address: string) {
+  var Json = getContractJSON(contractName)
+  var web3 = getDefaultWeb3()
+  return new web3.eth.Contract(Json.abi, address)
+}
+
+export function getDepolyedContract(contractName: string): Contract {
+  var Json = getContractJSON(contractName)
+  var networkId = process.env.NETWORK_ID
+  var deployedAddress = getContractJSON(contractName).networks[networkId].address
+  var web3 = getDefaultWeb3()
+  return new web3.eth.Contract(Json.abi, deployedAddress)
+}
+
+export async function newContract(contractName: string, args: any[] = []): Promise<Contract> {
+  var web3 = getDefaultWeb3()
+  var Json = getContractJSON(contractName)
+  var contract = new web3.eth.Contract(Json.abi)
+  var adminAccount = (await web3.eth.getAccounts())[0]
+  let parameter = {
+    from: adminAccount,
+    gas: process.env["COVERAGE"] ? 10000000000 : 7000000,
+    gasPrice: web3.utils.toHex(web3.utils.toWei('1', 'wei'))
+  }
+  return await contract.deploy({ data: Json.byteCode, arguments: args }).send(parameter)
+}
--- a/test/utils-v1/Converter.ts
+++ b/test/utils-v1/Converter.ts
@@ -0,0 +1,15 @@
+import BigNumber from "bignumber.js";
+
+export const MAX_UINT256 = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+
+export function decimalStr(value: string): string {
+  return new BigNumber(value).multipliedBy(10 ** 18).toFixed(0, BigNumber.ROUND_DOWN)
+}
+
+export function mweiStr(value: string): string {
+  return new BigNumber(value).multipliedBy(10 ** 6).toFixed(0, BigNumber.ROUND_DOWN)
+}
+
+export function gweiStr(gwei: string): string {
+  return new BigNumber(gwei).multipliedBy(10 ** 9).toFixed(0, BigNumber.ROUND_DOWN)
+}
--- a/test/utils-v1/EVM.ts
+++ b/test/utils-v1/EVM.ts
@@ -0,0 +1,92 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+// require('dotenv-flow').config();
+
+import { JsonRpcPayload, JsonRpcResponse } from 'web3-core-helpers';
+import Web3 from 'web3';
+
+export function getDefaultWeb3() {
+  return new Web3(process.env.RPC_NODE_URI)
+}
+
+export class EVM {
+  private provider = new Web3.providers.HttpProvider(process.env.RPC_NODE_URI);
+
+  public async reset(id: string): Promise<string> {
+    if (!id) {
+      throw new Error('id must be set');
+    }
+
+    await this.callJsonrpcMethod('evm_revert', [id]);
+
+    return this.snapshot();
+  }
+
+  public async snapshot(): Promise<string> {
+    return this.callJsonrpcMethod('evm_snapshot');
+  }
+
+  public async evmRevert(id: string): Promise<string> {
+    return this.callJsonrpcMethod('evm_revert', [id]);
+  }
+
+  public async stopMining(): Promise<string> {
+    return this.callJsonrpcMethod('miner_stop');
+  }
+
+  public async startMining(): Promise<string> {
+    return this.callJsonrpcMethod('miner_start');
+  }
+
+  public async mineBlock(): Promise<string> {
+    return this.callJsonrpcMethod('evm_mine');
+  }
+
+  public async fastMove(moveBlockNum: number): Promise<string> {
+    var res: string
+    for (let i = 0; i < moveBlockNum; i++) {
+      res = await this.callJsonrpcMethod('evm_mine');
+    }
+    return res
+  }
+
+  public async increaseTime(duration: number): Promise<string> {
+    await this.callJsonrpcMethod('evm_increaseTime', [duration]);
+    return this.callJsonrpcMethod('evm_mine');
+  }
+
+  public async callJsonrpcMethod(method: string, params?: (any[])): Promise<string> {
+    const args: JsonRpcPayload = {
+      method,
+      params,
+      jsonrpc: '2.0',
+      id: new Date().getTime(),
+    };
+
+    const response = await this.send(args);
+
+    return response.result;
+  }
+
+  private async send(args: JsonRpcPayload): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const callback: any = (error: Error, val: JsonRpcResponse): void => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(val);
+        }
+      };
+
+      this.provider.send(
+        args,
+        callback,
+      );
+    });
+  }
+}
--- a/test/utils-v1/Log.ts
+++ b/test/utils-v1/Log.ts
@@ -0,0 +1,30 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+export const blueText = x => `\x1b[36m${x}\x1b[0m`;
+export const yellowText = x => `\x1b[33m${x}\x1b[0m`;
+export const greenText = x => `\x1b[32m${x}\x1b[0m`;
+export const redText = x => `\x1b[31m${x}\x1b[0m`;
+export const numberWithCommas = x => x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+
+export async function logGas(funcCall: any, params: any, desc: string) {
+  const estimatedGas = await funcCall.estimateGas(params)
+  const receipt = await funcCall.send(params)
+  const gasUsed = receipt.gasUsed;
+  let colorFn;
+
+  if (gasUsed < 80000) {
+    colorFn = greenText;
+  } else if (gasUsed < 200000) {
+    colorFn = yellowText;
+  } else {
+    colorFn = redText;
+  }
+
+  console.log(("Gas estimated:" + numberWithCommas(estimatedGas)).padEnd(60, '.'), blueText(desc) + "  ", colorFn(numberWithCommas(gasUsed).padStart(5)));
+  return receipt
+}