Merge branch 'feature/V2' of github.com:DODOEX/contractV2 into feature/V2

2020-11-25 22:22:14 +08:00
parent da543d711a 3a16e0e7e1
commit d6e16d5c52
5 changed files with 94 additions and 32 deletions
--- a/contracts/DODOPrivatePool/impl/DPP.sol
+++ b/contracts/DODOPrivatePool/impl/DPP.sol
@@ -30,7 +30,6 @@ contract DPP is DPPTrader {
        address tradePermissionManager
    ) external {
        initOwner(owner);
-        _ADMIN_ = owner;
        _MAINTAINER_ = maintainer;
        _OPERATOR_ = operator;
        _BASE_TOKEN_ = IERC20(baseTokenAddress);
--- a/contracts/DODOPrivatePool/impl/DPPStorage.sol
+++ b/contracts/DODOPrivatePool/impl/DPPStorage.sol
@@ -27,7 +27,6 @@ import {PMMPricing} from "../../lib/PMMPricing.sol";
 contract DPPStorage is InitializableOwnable, ReentrancyGuard {
    using SafeMath for uint256;

-    address public _ADMIN_;
    address public _DODO_SMART_APPROVE_;

    // ============ Variables for Control ============
--- a/contracts/SmartRoute/DODOV2Proxy01.sol
+++ b/contracts/SmartRoute/DODOV2Proxy01.sol
@@ -142,7 +142,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
        require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,"DODOV2Proxy01: withdraw amount is not enough");
    }

-    //TODO:ETH 
    function createDODOPrivatePool(
        address baseToken,
        address quoteToken,
@@ -155,10 +154,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
        newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
-        if(baseInAmount > 0) 
-            IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
-        if(quoteInAmount > 0)
-            IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
+        if(baseInAmount > 0){
+            if(baseToken != ETH_ADDRESS){
+                IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
+            }else {
+                require(msg.value == baseInAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
+                IWETH(_WETH_).deposit{value: baseInAmount}();
+                assert(IWETH(_WETH_).transfer(newPrivatePool, baseInAmount));
+                baseToken = _WETH_;
+            }
+        }
+        if(quoteInAmount > 0){
+            if(quoteToken != ETH_ADDRESS){
+                IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
+            }else {
+                require(msg.value == quoteInAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
+                IWETH(_WETH_).deposit{value: quoteInAmount}();
+                assert(IWETH(_WETH_).transfer(newPrivatePool, quoteInAmount));
+                quoteToken = _WETH_;
+            }
+        }
        IDODOV2(dppFactory).initDODOPrivatePool(
            newPrivatePool,
            msg.sender,
--- a/test/Proxy/proxy.dpp.test.ts
+++ b/test/Proxy/proxy.dpp.test.ts
@@ -27,9 +27,6 @@ async function init(ctx: ProxyContext): Promise<void> {
  lp = ctx.SpareAccounts[0];
  project = ctx.SpareAccounts[1];
  trader = ctx.SpareAccounts[2];
-  await ctx.approveProxy(lp);
-  await ctx.approveProxy(project);
-  await ctx.approveProxy(trader);

  await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
  await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
@@ -40,14 +37,18 @@ async function init(ctx: ProxyContext): Promise<void> {

  // await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
  // await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
+
+  await ctx.approveProxy(lp);
+  await ctx.approveProxy(project);
+  await ctx.approveProxy(trader);
 }


-async function initCreateDPP(ctx: ProxyContext, token0: any, token1:any, token0Amount: string, token1Amount: string): Promise<void> {
+async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string): Promise<string> {
  let PROXY = ctx.DODOProxy;
  await PROXY.methods.createDODOPrivatePool(
-    token0.options.address,
-    token1.options.address,
+    token0,
+    token1,
    token0Amount,
    token1Amount,
    config.lpFeeRate,
@@ -55,18 +56,26 @@ async function initCreateDPP(ctx: ProxyContext, token0: any, token1:any, token0A
    config.i,
    config.k,
    Math.floor(new Date().getTime()/1000 + 60 * 10)
-  ).send(ctx.sendParam(project));
+  ).send(ctx.sendParam(project,ethValue));
+  if(token0 == '0x000000000000000000000000000000000000000E') token0 = ctx.WETH.options.address;
+  if(token1 == '0x000000000000000000000000000000000000000E') token1 = ctx.WETH.options.address;
+  var addr = await ctx.DPPFactory.methods._REGISTRY_(token0,token1,0).call();
+  return addr;
 }

 describe("DODOProxyV2.0", () => {
  let snapshotId: string;
  let ctx: ProxyContext;
+  let dpp_DODO_USDT: string;
+  let dpp_WETH_USDT: string;

  before(async () => {
    ctx = await getProxyContext();
    await init(ctx);
-    // await initCreateDPP(ctx,ctx.DODO,ctx.USDT,decimalStr("10000"),decimalStr("10000"));
-    // await initCreateDPP(ctx,ctx.WETH,ctx.USDT,decimalStr("50"),decimalStr("10000"));
+    dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("10000"),mweiStr("10000"),"0");
+    dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("10"),mweiStr("10000"),"10");
+    console.log("dpp_DODO_USDT:",dpp_DODO_USDT);
+    console.log("dpp_WETH_USDT:",dpp_WETH_USDT);
  });

  beforeEach(async () => {
@@ -78,19 +87,16 @@ describe("DODOProxyV2.0", () => {
  });

  describe("DODOProxy", () => {
-    /**
-     * 1. 创建空池子
-     * 2. 创建ERC20 DPP
-     * 3. 创建ETH && ERC20 Token 
-     */
-    it("createDPP - empty", async () => {
+    it("createDPP", async () => {
      var baseToken = ctx.DODO.options.address;
      var quoteToken = ctx.USDT.options.address;
+      var baseAmount = decimalStr("10000");
+      var quoteAmount = mweiStr("10000");
      await ctx.DODOProxy.methods.createDODOPrivatePool(
        baseToken,
        quoteToken,
-        decimalStr("0"),
-        decimalStr("0"),
+        baseAmount,
+        quoteAmount,
        config.lpFeeRate,
        config.mtFeeRate,
        config.i,
@@ -99,17 +105,63 @@ describe("DODOProxyV2.0", () => {
      ).send(ctx.sendParam(project));
      var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken,quoteToken).call();
      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
-      console.log("dppInfo:",dppInfo);
      assert.equal(
        dppInfo[0],
        project
      );
+      assert.equal(
+        await ctx.DODO.methods.balanceOf(addrs[0]).call(),
+        baseAmount
+      );
+      assert.equal(
+        await ctx.USDT.methods.balanceOf(addrs[0]).call(),
+        quoteAmount
+      );
    });


+    it("createDPP - ETH", async () => {
+      var baseToken = '0x000000000000000000000000000000000000000E';
+      var quoteToken = ctx.USDT.options.address;
+      var baseAmount = decimalStr("10");
+      var quoteAmount = mweiStr("10000");
+      await ctx.DODOProxy.methods.createDODOPrivatePool(
+        baseToken,
+        quoteToken,
+        baseAmount,
+        quoteAmount,
+        config.lpFeeRate,
+        config.mtFeeRate,
+        config.i,
+        config.k,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ).send(ctx.sendParam(project, "10"));
+      var addrs = await ctx.DPPFactory.methods.getPrivatePool(ctx.WETH.options.address,quoteToken).call();
+      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
+      assert.equal(
+        dppInfo[0],
+        project
+      );
+      assert.equal(
+        await ctx.WETH.methods.balanceOf(addrs[0]).call(),
+        baseAmount
+      );
+      assert.equal(
+        await ctx.USDT.methods.balanceOf(addrs[0]).call(),
+        quoteAmount
+      );
+    });
+
    it("resetDPP", async () => {
-        //需要存钱
-        //需要退钱
+      // await ctx.DODOProxy.methods.resetDODOPrivatePool(
+      //   dpp_DODO_USDT,
+      //   config.lpFeeRate,
+      //   config.mtFeeRate,
+      //   config.i,
+      //   config.k,
+        
+      //   Math.floor(new Date().getTime()/1000 + 60 * 10)
+      // ).send(ctx.sendParam(project, "10"));
    });


--- a/test/utils/ProxyContext.ts
+++ b/test/utils/ProxyContext.ts
@@ -48,7 +48,7 @@ export class ProxyContext {
    this.Maintainer = allAccounts[1];
    this.SpareAccounts = allAccounts.slice(2, 10);

-    var WETH = await contracts.newContract(
+    this.WETH = await contracts.newContract(
      contracts.WETH_CONTRACT_NAME
    );

@@ -101,7 +101,7 @@ export class ProxyContext {
      [
        this.DVMFactory.options.address,
        this.DPPFactory.options.address,
-        WETH.options.address,
+        this.WETH.options.address,
        this.SmartApprove.options.address,
        dodoSellHelper.options.address
      ]
@@ -117,9 +117,6 @@ export class ProxyContext {
      contracts.MINTABLE_ERC20_CONTRACT_NAME,
      ["USDT Token", "USDT", 6]
    );
-    this.WETH = await contracts.newContract(
-      contracts.WETH_CONTRACT_NAME
-    );

    console.log(log.blueText("[Init DVM context]"));
  }