add route test framework

.gitignore

@@ -15,3 +15,9 @@ flattered/
 *.swo
 *.swp
 
+
+node_modules
+
+#Hardhat files
+cache
+artifacts

contracts/SmartRoute/SmartApprove.sol

@@ -0,0 +1,36 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {IERC20} from "../intf/IERC20.sol";
+import {SafeERC20} from "../lib/SafeERC20.sol";
+import {Ownable} from "../lib/Ownable.sol";
+
+
+contract SmartApprove is Ownable {
+    using SafeERC20 for IERC20;
+    address public smartSwap;
+
+    function setSmartSwap(address _smartSwap) external onlyOwner {
+        smartSwap = _smartSwap;
+    }
+
+    
+    event Test1(uint256 amount);
+
+    function claimTokens(
+        IERC20 token,
+        address who,
+        address dest,
+        uint256 amount
+    ) external {
+        require(msg.sender == smartSwap, "Not SmartSwap Address, Access restricted");
+        emit Test1(amount);
+        // token.safeTransferFrom(who, dest, amount);
+    }
+}

contracts/SmartRoute/SmartSwap.sol

@@ -0,0 +1,118 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {Ownable} from "../lib/Ownable.sol";
+import {ExternalCall} from "../lib/ExternalCall.sol";
+import {IERC20} from "../intf/IERC20.sol";
+import {UniversalERC20} from "../lib/UniversalERC20.sol";
+import {SafeMath} from "../lib/SafeMath.sol";
+import {DecimalMath} from "../lib/DecimalMath.sol";
+import {ISmartApprove} from "../intf/ISmartApprove.sol";
+
+
+contract SmartSwap is Ownable {
+    using SafeMath for uint256;
+    using UniversalERC20 for IERC20;
+    using ExternalCall for address;
+
+    ISmartApprove public smartApprove;
+
+    IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
+
+    event Swapped(
+        IERC20 indexed fromToken,
+        IERC20 indexed toToken,
+        address indexed sender,
+        uint256 fromAmount,
+        uint256 toAmount
+    );
+
+    event ExternalRecord(address indexed to, address indexed sender);
+
+    constructor(address _smartApprove) public {
+        smartApprove = ISmartApprove(_smartApprove);
+    }
+
+
+    function dodoSwap(
+        IERC20 fromToken,
+        IERC20 toToken,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        address[] memory callPairs,
+        bytes memory callDataConcat,
+        uint256[] memory starts,
+        uint256[] memory gasLimitsAndValues
+    ) public payable returns (uint256 returnAmount) {
+        require(minReturnAmount > 0, "haha hihi Min return should be bigger then 0.");
+        require(callPairs.length > 0, "pairs should exists.");
+
+        // if (fromToken != ETH_ADDRESS) {
+        //     // smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
+        // }
+
+        // for (uint256 i = 0; i < callPairs.length; i++) {
+        //     require(callPairs[i] != address(smartApprove), "Access denied");
+        //     require(
+        //         callPairs[i].externalCall(
+        //             gasLimitsAndValues[i] & ((1 << 128) - 1),
+        //             callDataConcat,
+        //             starts[i],
+        //             starts[i + 1] - starts[i],
+        //             gasLimitsAndValues[i] >> 128
+        //         )
+        //     );
+        // }
+
+        // // Return back all unswapped
+        // fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
+
+        // returnAmount = toToken.universalBalanceOf(address(this));
+
+        // require(returnAmount >= minReturnAmount, "Return amount is not enough");
+        // toToken.universalTransfer(msg.sender, returnAmount);
+        emit Swapped(fromToken, toToken, msg.sender, fromTokenAmount, fromTokenAmount);
+        // emit Swapped(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
+    }
+
+    function externalSwap(
+        IERC20 fromToken,
+        IERC20 toToken,
+        address approveTarget,
+        address to,
+        uint256 gasSwap,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        bytes memory callDataConcat
+    ) public payable returns (uint256 returnAmount) {
+        
+        require(minReturnAmount > 0, "Min return should be bigger then 0.");
+
+        if (fromToken != ETH_ADDRESS) {
+            smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
+            fromToken.approve(approveTarget, fromTokenAmount);
+        }
+
+        (bool success, ) = to.call{value: msg.value, gas: gasSwap}(callDataConcat);
+
+        require(success, "Contract Swap execution Failed");
+
+        // Return back all unswapped
+        fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
+
+        returnAmount = toToken.universalBalanceOf(address(this));
+
+        require(returnAmount >= minReturnAmount, "Return amount is not enough");
+        toToken.universalTransfer(msg.sender, returnAmount);
+
+        emit Swapped(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
+
+        emit ExternalRecord(to, msg.sender);
+    }
+}

contracts/intf/ISmartApprove.sol

@@ -0,0 +1,15 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {IERC20} from "./IERC20.sol";
+
+interface ISmartApprove {
+    function claimTokens(IERC20 token,address who,address dest,uint256 amount) external;
+}

contracts/lib/ExternalCall.sol

@@ -0,0 +1,34 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+library ExternalCall {
+    // Source: https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol
+    // call has been separated into its own function in order to take advantage
+    // of the Solidity's code generator to produce a loop that copies tx.data into memory.
+    function externalCall(address destination, uint value, bytes memory data, uint dataOffset, uint dataLength, uint gasLimit) internal returns(bool result) {
+        // solium-disable-next-line security/no-inline-assembly
+        if (gasLimit == 0) {
+            gasLimit = gasleft() - 40000;
+        }
+        assembly {
+            let x := mload(0x40)   // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
+            let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
+            result := call(
+                gasLimit,
+                destination,
+                value,
+                add(d, dataOffset),
+                dataLength,        // Size of the input (in bytes) - this is what fixes the padding problem
+                x,
+                0                  // Output is ignored, therefore the output size is zero
+            )
+        }
+    }
+}

contracts/lib/UniversalERC20.sol

@@ -0,0 +1,75 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {SafeMath} from "./SafeMath.sol";
+import {IERC20} from "../intf/IERC20.sol";
+import {SafeERC20} from "./SafeERC20.sol";
+
+library UniversalERC20 {
+
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    IERC20 private constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
+    IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
+
+    function universalTransfer(IERC20 token, address to, uint256 amount) internal {
+        universalTransfer(token, to, amount, false);
+    }
+
+    function universalTransfer(IERC20 token, address to, uint256 amount, bool mayFail) internal returns(bool) {
+        if (amount == 0) {
+            return true;
+        }
+
+        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
+            if (mayFail) {
+                return address(uint160(to)).send(amount);
+            } else {
+                address(uint160(to)).transfer(amount);
+                return true;
+            }
+        } else {
+            token.safeTransfer(to, amount);
+            return true;
+        }
+    }
+
+    function universalApprove(IERC20 token, address to, uint256 amount) internal {
+        if (token != ZERO_ADDRESS && token != ETH_ADDRESS) {
+            token.safeApprove(to, amount);
+        }
+    }
+
+    function universalTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
+        if (amount == 0) {
+            return;
+        }
+
+        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
+            require(from == msg.sender && msg.value >= amount, "msg.value is zero");
+            if (to != address(this)) {
+                address(uint160(to)).transfer(amount);
+            }
+            if (msg.value > amount) {
+                msg.sender.transfer(msg.value.sub(amount));
+            }
+        } else {
+            token.safeTransferFrom(from, to, amount);
+        }
+    }
+
+    function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) {
+        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
+            return who.balance;
+        } else {
+            return token.balanceOf(who);
+        }
+    }
+}

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/
+  //     );
+  //   });
+  // });
+});

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;
+}

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)
+}

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)
+}

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,
+      );
+    });
+  }
+}

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
+}

tsconfig.json

@@ -7,7 +7,7 @@
     "sourceMap": true,
     "declaration": true,
     "downlevelIteration": true,
-    "noUnusedLocals": true,
+    // "noUnusedLocals": true,
     "esModuleInterop": true,
     "outDir": "dist",
     "resolveJsonModule": true,