diff --git a/contracts/DODOVendingMachine/impl/DVM.sol b/contracts/DODOVendingMachine/impl/DVM.sol index 8cd0f0e..0f24422 100644 --- a/contracts/DODOVendingMachine/impl/DVM.sol +++ b/contracts/DODOVendingMachine/impl/DVM.sol @@ -30,7 +30,6 @@ contract DVM is DVMTrader, DVMFunding { uint256 k ) external { initOwner(owner); - _ADMIN_ = owner; _BASE_TOKEN_ = IERC20(baseTokenAddress); _QUOTE_TOKEN_ = IERC20(quoteTokenAddress); _LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel); diff --git a/contracts/DODOVendingMachine/impl/DVMFunding.sol b/contracts/DODOVendingMachine/impl/DVMFunding.sol index e0eaf6c..da3f465 100644 --- a/contracts/DODOVendingMachine/impl/DVMFunding.sol +++ b/contracts/DODOVendingMachine/impl/DVMFunding.sol @@ -28,26 +28,25 @@ contract DVMFunding is DVMVault { require(baseInput > 0, "NO_BASE_INPUT"); uint256 baseReserve = _BASE_RESERVE_; uint256 quoteReserve = _QUOTE_RESERVE_; - uint256 mintAmount; // case 1. initial supply // 包含了 baseReserve == 0 && quoteReserve == 0 的情况 // 在提币的时候向下取整。因此永远不会出现，balance为0但totalsupply不为0的情况 // 但有可能出现，reserve>0但totalSupply=0的场景 if (totalSupply == 0) { - mintAmount = getBaseBalance(); // 以免出现balance很大但shares很小的情况 + shares = getBaseBalance(); // 以免出现balance很大但shares很小的情况 } else if (baseReserve > 0 && quoteReserve == 0) { // case 2. supply when quote reserve is 0 - mintAmount = baseInput.mul(totalSupply).div(baseReserve); + shares = baseInput.mul(totalSupply).div(baseReserve); } else if (baseReserve > 0 && quoteReserve > 0) { // case 3. normal case uint256 baseInputRatio = DecimalMath.divFloor(baseInput, baseReserve); uint256 quoteInputRatio = DecimalMath.divFloor(quoteInput, quoteReserve); uint256 mintRatio = quoteInputRatio < baseInputRatio ? quoteInputRatio : baseInputRatio; - mintAmount = DecimalMath.mulFloor(totalSupply, mintRatio); + shares = DecimalMath.mulFloor(totalSupply, mintRatio); } - _mint(to, mintAmount); + _mint(to, shares); _sync(); - return (mintAmount, baseInput, quoteInput); + return (shares, baseInput, quoteInput); } // withdraw amount [round down] diff --git a/contracts/DODOVendingMachine/impl/DVMStorage.sol b/contracts/DODOVendingMachine/impl/DVMStorage.sol index af94161..b7e4aed 100644 --- a/contracts/DODOVendingMachine/impl/DVMStorage.sol +++ b/contracts/DODOVendingMachine/impl/DVMStorage.sol @@ -21,8 +21,6 @@ import {IERC20} from "../../intf/IERC20.sol"; contract DVMStorage is InitializableOwnable, ReentrancyGuard { using SafeMath for uint256; - address public _ADMIN_; - // ============ Variables for Control ============ IExternalValue public _GAS_PRICE_LIMIT_; diff --git a/contracts/SmartRoute/DODOV2Proxy01.sol b/contracts/SmartRoute/DODOV2Proxy01.sol index bf95780..38a45bc 100644 --- a/contracts/SmartRoute/DODOV2Proxy01.sol +++ b/contracts/SmartRoute/DODOV2Proxy01.sol @@ -44,8 +44,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { uint256 returnAmount, uint256 timeStamp ); - - event ExternalRecord(address indexed to, address indexed sender); //======================================================================== constructor( @@ -62,8 +60,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { dodoSellHelper = _dodoSellHelper; } - //TODO:ETH function createDODOVendingMachine( + address assetTo, address baseToken, address quoteToken, uint256 baseInAmount, @@ -74,13 +72,30 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { uint256 k, uint256 deadline ) external virtual override payable judgeExpired(deadline) returns (address newVendingMachine,uint256 shares) { - require(k > 0 && k<= 10**18, 'DODOV2Proxy01: K OUT OF RANGE'); - newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(msg.sender, baseToken,quoteToken,lpFeeRate,mtFeeRate,i,k); - if(baseInAmount > 0) - IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount); - if(quoteInAmount > 0) - IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount); - (shares,,) = IDODOV2(newVendingMachine).buyShares(msg.sender); + { + address _baseToken = baseToken == ETH_ADDRESS ? _WETH_ : baseToken; + address _quoteToken = quoteToken == ETH_ADDRESS ? _WETH_ : quoteToken; + newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(msg.sender, _baseToken, _quoteToken, lpFeeRate, mtFeeRate, i, k); + } + if(baseInAmount > 0){ + if(baseToken != ETH_ADDRESS){ + IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount); + }else { + require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); + IWETH(_WETH_).deposit{value: baseInAmount}(); + assert(IWETH(_WETH_).transfer(newVendingMachine, baseInAmount)); + } + } + if(quoteInAmount > 0){ + if(quoteToken != ETH_ADDRESS){ + IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount); + }else { + require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); + IWETH(_WETH_).deposit{value: quoteInAmount}(); + assert(IWETH(_WETH_).transfer(newVendingMachine, quoteInAmount)); + } + } + (shares,,) = IDODOV2(newVendingMachine).buyShares(assetTo); } @@ -112,7 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { } } - //TODO:ETH function addDVMLiquidity( address DVMAddress, address to, @@ -121,18 +135,52 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { uint256 baseMinAmount, uint256 quoteMinAmount, uint256 deadline - ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) { + ) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) { (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount); address _dvm = DVMAddress; - if(baseAdjustedInAmount > 0) + if(baseAdjustedInAmount > 0) { IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount); + } if(quoteAdjustedInAmount > 0) IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount); (shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to); require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough'); } - //TODO:ETH 构造data + function addDVMLiquidityETH( + address DVMAddress, + address to, + uint256 baseInAmount, + uint256 quoteInAmount, + uint256 baseMinAmount, + uint256 quoteMinAmount, + uint8 flag, // 1 - baseInETH, 2 - quoteInETH + uint256 deadline + ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) { + (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount); + address _dvm = DVMAddress; + if(baseAdjustedInAmount > 0) { + if(flag == 1) { + require(msg.value >= baseAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); + IWETH(_WETH_).deposit{value: baseAdjustedInAmount}(); + assert(IWETH(_WETH_).transfer(_dvm, baseAdjustedInAmount)); + }else { + IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount); + } + } + if(quoteAdjustedInAmount > 0){ + if(flag == 2) { + require(msg.value >= quoteAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); + IWETH(_WETH_).deposit{value: quoteAdjustedInAmount}(); + assert(IWETH(_WETH_).transfer(_dvm, quoteAdjustedInAmount)); + }else { + IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount); + } + } + (shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to); + require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough'); + } + function removeDVMLiquidity( address DVMAddress, address to, @@ -140,9 +188,9 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { uint256 baseOutMinAmount, uint256 quoteOutMinAmount, uint256 deadline - ) external virtual override payable judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) { + ) external virtual override judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) { require(shares > 0, 'DODOV2Proxy01: Insufficient_Liquidity'); - (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to, shares, ""); + (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to); require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,'DODOV2Proxy01: withdraw amount is not enough'); } @@ -292,8 +340,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { } } - function dodoSwap( - address fromToken, + function dodoSwapETHToToken( + address payable assetTo, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, @@ -301,42 +349,95 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { uint256[] memory directions, uint256 deadline ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) { - require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger than 0."); - require(dodoPairs.length > 0, "DODOV2Proxy01: pairs should exists."); - - if (fromToken != ETH_ADDRESS) { - IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); - } else { - require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH"); - IWETH(_WETH_).deposit{value: fromTokenAmount}(); - IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this))); - } + require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.'); + require(msg.value == fromTokenAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); + IWETH(_WETH_).deposit{value: fromTokenAmount}(); + IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this))); for (uint256 i = 0; i < dodoPairs.length; i++) { - address curTo; if(i == dodoPairs.length - 1){ - curTo = address(this); + if (directions[i] == 0) { + returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo); + } else { + returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo); + } } else { - curTo = dodoPairs[i+1]; - } - if (directions[i] == 0) { - IDODOV2(dodoPairs[i]).sellBase(curTo); - } else { - IDODOV2(dodoPairs[i]).sellQuote(curTo); + if (directions[i] == 0) { + IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]); + } else { + IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]); + } } } - IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this))); + require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough'); + emit OrderHistory(ETH_ADDRESS, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp); + } - if (toToken == ETH_ADDRESS) { - uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this)); - IWETH(_WETH_).withdraw(wethAmount); + function dodoSwapTokenToETH( + address payable assetTo, + address fromToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256[] memory directions, + uint256 deadline + ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) { + require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.'); + IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); + + for (uint256 i = 0; i < dodoPairs.length; i++) { + if(i == dodoPairs.length - 1){ + if (directions[i] == 0) { + IDODOV2(dodoPairs[i]).sellBase(address(this)); + } else { + IDODOV2(dodoPairs[i]).sellQuote(address(this)); + } + } else { + if (directions[i] == 0) { + IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]); + } else { + IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]); + } + } } + returnAmount = IWETH(_WETH_).balanceOf(address(this)); + IWETH(_WETH_).withdraw(returnAmount); + require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough'); + IERC20(ETH_ADDRESS).universalTransfer(assetTo, returnAmount); + emit OrderHistory(fromToken, ETH_ADDRESS, assetTo, fromTokenAmount, returnAmount, block.timestamp); + } - returnAmount = IERC20(toToken).universalBalanceOf(address(this)); - require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough"); - IERC20(toToken).universalTransfer(msg.sender, returnAmount); - emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp); + function dodoSwapTokenToToken( + address payable assetTo, + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256[] memory directions, + uint256 deadline + ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) { + require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.'); + IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); + + for (uint256 i = 0; i < dodoPairs.length; i++) { + if(i == dodoPairs.length - 1){ + if (directions[i] == 0) { + returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo); + } else { + returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo); + } + } else { + if (directions[i] == 0) { + IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]); + } else { + IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]); + } + } + } + require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough'); + emit OrderHistory(fromToken, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp); } function externalSwap( @@ -344,32 +445,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 { address toToken, address approveTarget, address to, - uint256 gasSwap, uint256 fromTokenAmount, uint256 minReturnAmount, bytes memory callDataConcat, uint256 deadline ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) { - - require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger then 0."); - + require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger then 0.'); if (fromToken != ETH_ADDRESS) { IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount); IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount); } - (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}( - callDataConcat - ); + (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(callDataConcat); - require(success, "DODOV2Proxy01: Contract Swap execution Failed"); + require(success, 'DODOV2Proxy01: Contract Swap execution Failed'); IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this))); returnAmount = IERC20(toToken).universalBalanceOf(address(this)); - require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough"); + require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough'); IERC20(toToken).universalTransfer(msg.sender, returnAmount); emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp); - emit ExternalRecord(to, msg.sender); } } diff --git a/contracts/intf/IDODOV2Proxy01.sol b/contracts/intf/IDODOV2Proxy01.sol index 447e3ac..427317d 100644 --- a/contracts/intf/IDODOV2Proxy01.sol +++ b/contracts/intf/IDODOV2Proxy01.sol @@ -11,8 +11,8 @@ pragma experimental ABIEncoderV2; import {IERC20} from "./IERC20.sol"; interface IDODOV2Proxy01 { - function dodoSwap( - address fromToken, + function dodoSwapETHToToken( + address payable assetTo, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, @@ -21,13 +21,32 @@ interface IDODOV2Proxy01 { uint256 deadline ) external payable returns (uint256 returnAmount); - + function dodoSwapTokenToETH( + address payable assetTo, + address fromToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256[] memory directions, + uint256 deadline + ) external returns (uint256 returnAmount); + + function dodoSwapTokenToToken( + address payable assetTo, + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256[] memory directions, + uint256 deadline + ) external returns (uint256 returnAmount); + function externalSwap( address fromToken, address toToken, address approveTarget, address to, - uint256 gasSwap, uint256 fromTokenAmount, uint256 minReturnAmount, bytes memory callDataConcat, @@ -36,6 +55,7 @@ interface IDODOV2Proxy01 { function createDODOVendingMachine( + address assetTo, address baseToken, address quoteToken, uint256 baseInAmount, @@ -56,6 +76,17 @@ interface IDODOV2Proxy01 { uint256 baseMinAmount, uint256 quoteMinAmount, uint256 deadline + ) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount); + + function addDVMLiquidityETH( + address DVMAddress, + address to, + uint256 baseInAmount, + uint256 quoteInAmount, + uint256 baseMinAmount, + uint256 quoteMinAmount, + uint8 flag, // 1 - baseInETH, 2 - quoteInETH + uint256 deadline ) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount); @@ -66,7 +97,7 @@ interface IDODOV2Proxy01 { uint256 baseOutMinAmount, uint256 quoteOutMinAmount, uint256 deadline - ) external payable returns (uint256 baseOutAmount,uint256 quoteOutAmount); + ) external returns (uint256 baseOutAmount,uint256 quoteOutAmount); function createDODOPrivatePool( diff --git a/test/Proxy/proxy.dpp.test.ts b/test/Proxy/proxy.dpp.test.ts index db7991e..2a38eb2 100644 --- a/test/Proxy/proxy.dpp.test.ts +++ b/test/Proxy/proxy.dpp.test.ts @@ -7,7 +7,7 @@ // import * as assert from 'assert'; import BigNumber from "bignumber.js"; -import { decimalStr, mweiStr} from '../utils/Converter'; +import { decimalStr, mweiStr } from '../utils/Converter'; import { logGas } from '../utils/Log'; import { ProxyContext, getProxyContext } from '../utils/ProxyContext'; import { assert } from 'chai'; @@ -30,12 +30,11 @@ async function init(ctx: ProxyContext): Promise { project = ctx.SpareAccounts[1]; trader = ctx.SpareAccounts[2]; - await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000")); - await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000")); - await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000")); + await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000")); + await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000")); - await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000")); - await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000")); + await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000")); + await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000")); // await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80')); // await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80')); @@ -46,7 +45,7 @@ async function init(ctx: ProxyContext): Promise { } -async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string): Promise { +async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise { let PROXY = ctx.DODOProxy; await PROXY.methods.createDODOPrivatePool( token0, @@ -55,7 +54,7 @@ async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, t token1Amount, config.lpFeeRate, config.mtFeeRate, - config.i, + i, config.k, Math.floor(new Date().getTime()/1000 + 60 * 10) ).send(ctx.sendParam(project,ethValue)); @@ -76,9 +75,9 @@ describe("DODOProxyV2.0", () => { before(async () => { ctx = await getProxyContext(); await init(ctx); - dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("10000"),mweiStr("10000"), "0"); + dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3")); DPP_DODO_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_DODO_USDT); - dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("10000"),"5"); + dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600")); DPP_WETH_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_WETH_USDT); console.log("dpp_DODO_USDT:",dpp_DODO_USDT); console.log("dpp_WETH_USDT:",dpp_WETH_USDT); @@ -110,17 +109,17 @@ describe("DODOProxyV2.0", () => { Math.floor(new Date().getTime()/1000 + 60 * 10) ),ctx.sendParam(project),"createDPP"); var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken,quoteToken).call(); - var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call(); + var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call(); assert.equal( dppInfo[0], project ); assert.equal( - await ctx.DODO.methods.balanceOf(addrs[0]).call(), + await ctx.DODO.methods.balanceOf(addrs[1]).call(), baseAmount ); assert.equal( - await ctx.USDT.methods.balanceOf(addrs[0]).call(), + await ctx.USDT.methods.balanceOf(addrs[1]).call(), quoteAmount ); }); @@ -143,17 +142,17 @@ describe("DODOProxyV2.0", () => { Math.floor(new Date().getTime()/1000 + 60 * 10) ),ctx.sendParam(project, "5"),"createDPP - Wrap ETH"); var addrs = await ctx.DPPFactory.methods.getPrivatePool(ctx.WETH.options.address,quoteToken).call(); - var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call(); + var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call(); assert.equal( dppInfo[0], project ); assert.equal( - await ctx.WETH.methods.balanceOf(addrs[0]).call(), + await ctx.WETH.methods.balanceOf(addrs[1]).call(), baseAmount ); assert.equal( - await ctx.USDT.methods.balanceOf(addrs[0]).call(), + await ctx.USDT.methods.balanceOf(addrs[1]).call(), quoteAmount ); }); @@ -161,13 +160,13 @@ describe("DODOProxyV2.0", () => { it("resetDPP", async () => { var beforeState = await DPP_DODO_USDT.methods.getPMMState().call(); assert.equal(beforeState.K,config.k); - assert.equal(beforeState.B0,decimalStr("10000")); - assert.equal(beforeState.Q0,mweiStr("10000")); + assert.equal(beforeState.B0,decimalStr("100000")); + assert.equal(beforeState.Q0,mweiStr("30000")); await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePool( dpp_DODO_USDT, config.lpFeeRate, config.mtFeeRate, - config.i, + mweiStr("0.3"), decimalStr("0.2"), decimalStr("1000"), mweiStr("1000"), @@ -177,21 +176,22 @@ describe("DODOProxyV2.0", () => { ),ctx.sendParam(project),"resetDPP"); var afterState = await DPP_DODO_USDT.methods.getPMMState().call(); assert.equal(afterState.K,decimalStr("0.2")); - assert.equal(afterState.B0,decimalStr("11000")); - assert.equal(afterState.Q0,mweiStr("11000")); + assert.equal(afterState.B0,decimalStr("101000")); + assert.equal(afterState.Q0,mweiStr("31000")); }); + it("resetDPP - OutETH", async () => { var beforeState = await DPP_WETH_USDT.methods.getPMMState().call(); assert.equal(beforeState.K,config.k); assert.equal(beforeState.B0,decimalStr("5")); - assert.equal(beforeState.Q0,mweiStr("10000")); + assert.equal(beforeState.Q0,mweiStr("30000")); var b_ETH = await ctx.Web3.eth.getBalance(project); var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH( dpp_WETH_USDT, config.lpFeeRate, config.mtFeeRate, - config.i, + mweiStr("600"), decimalStr("0.2"), decimalStr("0"), mweiStr("1000"), @@ -199,16 +199,172 @@ describe("DODOProxyV2.0", () => { mweiStr("0"), 3, Math.floor(new Date().getTime()/1000 + 60 * 10) - ),ctx.sendParam(project),"resetDPP-ETH"); + ),ctx.sendParam(project),"resetDPP-OutETH"); var afterState = await DPP_WETH_USDT.methods.getPMMState().call(); assert.equal(afterState.K,decimalStr("0.2")); assert.equal(afterState.B0,decimalStr("4")); - assert.equal(afterState.Q0,mweiStr("11000")); + assert.equal(afterState.Q0,mweiStr("31000")); var a_ETH = await ctx.Web3.eth.getBalance(project); console.log("b_ETH:",b_ETH); console.log("a_ETH:",a_ETH); - assert.equal(new BigNumber(a_ETH).isGreaterThan(new BigNumber(b_ETH)),true); + assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).minus(decimalStr("1"))),true); }); + + it("resetDPP - InETH", async () => { + var beforeState = await DPP_WETH_USDT.methods.getPMMState().call(); + assert.equal(beforeState.K,config.k); + assert.equal(beforeState.B0,decimalStr("5")); + assert.equal(beforeState.Q0,mweiStr("30000")); + var b_ETH = await ctx.Web3.eth.getBalance(project); + var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH( + dpp_WETH_USDT, + config.lpFeeRate, + config.mtFeeRate, + mweiStr("600"), + decimalStr("0.2"), + decimalStr("1"), + mweiStr("1000"), + decimalStr("0"), + mweiStr("0"), + 1, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(project,"1"),"resetDPP-InETH"); + var afterState = await DPP_WETH_USDT.methods.getPMMState().call(); + assert.equal(afterState.K,decimalStr("0.2")); + assert.equal(afterState.B0,decimalStr("6")); + assert.equal(afterState.Q0,mweiStr("31000")); + var a_ETH = await ctx.Web3.eth.getBalance(project); + console.log("b_ETH:",b_ETH); + console.log("a_ETH:",a_ETH); + assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).plus(decimalStr("1"))),true); + }); + + it("swap - one hop", async () => { + await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000")); + var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var b_USDT = await ctx.USDT.methods.balanceOf(trader).call(); + var dodoPairs = [ + dpp_DODO_USDT + ] + var directions = [ + 0 + ] + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + trader, + ctx.DODO.options.address, + ctx.USDT.options.address, + decimalStr("500"), + 1, + dodoPairs, + directions, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(trader),"swap - one hop"); + var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var a_USDT = await ctx.USDT.methods.balanceOf(trader).call(); + console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD); + console.log("b_USDT:" + b_USDT + " a_USDT:" + a_USDT); + assert.equal(a_DOOD,decimalStr("500")); + assert.equal(a_USDT,"149474924"); + }); + + + it("swap - two hop", async () => { + await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000")); + var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var b_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + var dodoPairs = [ + dpp_DODO_USDT, + dpp_WETH_USDT + ] + var directions = [ + 0, + 1 + ] + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + trader, + ctx.DODO.options.address, + ctx.WETH.options.address, + decimalStr("500"), + 1, + dodoPairs, + directions, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(trader),"swap - two hop"); + var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var a_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD); + console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH); + assert.equal(a_DOOD,decimalStr("500")); + assert.equal(a_WETH,"247088894507188480"); + }); + + it("swap - two hop - inETH", async () => { + var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var b_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + var b_ETH = await ctx.Web3.eth.getBalance(trader); + var dodoPairs = [ + dpp_WETH_USDT, + dpp_DODO_USDT + ] + var directions = [ + 0, + 1 + ] + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken( + trader, + ctx.DODO.options.address, + decimalStr("1"), + 1, + dodoPairs, + directions, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(trader,"1"),"swap - two hop - inETH"); + var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var a_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + var a_ETH = await ctx.Web3.eth.getBalance(trader); + console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD); + console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH); + console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH); + assert.equal(a_DOOD,"1979965731049456633086"); + }); + + + it("swap - two hop - outETH", async () => { + await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000")); + var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var b_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + var b_ETH = await ctx.Web3.eth.getBalance(trader); + var dodoPairs = [ + dpp_DODO_USDT, + dpp_WETH_USDT + ] + var directions = [ + 0, + 1 + ] + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH( + trader, + ctx.DODO.options.address, + decimalStr("10000"), + 1, + dodoPairs, + directions, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(trader),"swap - two hop - outETH"); + var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); + var a_WETH = await ctx.WETH.methods.balanceOf(trader).call(); + var a_ETH = await ctx.Web3.eth.getBalance(trader); + console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD); + console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH); + console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH); + assert.equal(a_DOOD,decimalStr("90000")); + assert.equal( + tx.events['OrderHistory'].returnValues['returnAmount'], + "3760778358599649282" + ) + }); + + }); }); diff --git a/test/Proxy/proxy.dvm.test.ts b/test/Proxy/proxy.dvm.test.ts index 6266de6..54a0e6c 100644 --- a/test/Proxy/proxy.dvm.test.ts +++ b/test/Proxy/proxy.dvm.test.ts @@ -6,11 +6,13 @@ */ // import * as assert from 'assert'; - -import { decimalStr, mweiStr} from '../utils/Converter'; +import BigNumber from "bignumber.js"; +import { decimalStr, mweiStr } from '../utils/Converter'; import { logGas } from '../utils/Log'; import { ProxyContext, getProxyContext } from '../utils/ProxyContext'; import { assert } from 'chai'; +import * as contracts from '../utils/Contracts'; +import { Contract } from 'web3-eth-contract'; let lp: string; let project: string; @@ -27,46 +29,59 @@ async function init(ctx: ProxyContext): Promise { 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")); - await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000")); + await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000")); + await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000")); - await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000")); - await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000")); + await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000")); + await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000")); // 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 initCreateDVM(ctx: ProxyContext, token0: any, token1:any, token0Amount: string, token1Amount: string): Promise { +async function initCreateDVM(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise { let PROXY = ctx.DODOProxy; await PROXY.methods.createDODOVendingMachine( - token0.options.address, - token1.options.address, + project, + token0, + token1, token0Amount, token1Amount, config.lpFeeRate, config.mtFeeRate, config.i, config.k, - Math.floor(new Date().getTime()/1000 + 60 * 10); - ).send(ctx.sendParam(project)); + Math.floor(new Date().getTime()/1000 + 60 * 10) + ).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.DVMFactory.methods._REGISTRY_(token0,token1,0).call(); + return addr; } describe("DODOProxyV2.0", () => { let snapshotId: string; let ctx: ProxyContext; + let dvm_DODO_USDT: string; + let dvm_WETH_USDT: string; + let DVM_DODO_USDT: Contract; + let DVM_WETH_USDT: Contract; before(async () => { ctx = await getProxyContext(); await init(ctx); - // await initCreateDVM(ctx,ctx.DODO,ctx.USDT,decimalStr("10000"),decimalStr("10000")); - // await initCreateDVM(ctx,ctx.WETH,ctx.USDT,decimalStr("50"),decimalStr("10000")); + dvm_DODO_USDT = await initCreateDVM(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3")); + DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_DODO_USDT); + dvm_WETH_USDT = await initCreateDVM(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600")); + DVM_WETH_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_WETH_USDT); + console.log("dvm_DODO_USDT:",dvm_DODO_USDT); + console.log("dvm_WETH_USDT:",dvm_WETH_USDT); }); beforeEach(async () => { @@ -78,30 +93,149 @@ describe("DODOProxyV2.0", () => { }); describe("DODOProxy", () => { - /** - * 1. 创建空池子 - * 2. 创建ERC20 Token DVM - * 3. 创建ETH && ERC20 Token - */ it("createDVM", async () => { - - }); - - /** - * 1. 添加ERC20 Amount - * 2. 添加ERC20 + ETH - */ - it("addLiquidityToDVM", async () => { - + var baseToken = ctx.DODO.options.address; + var quoteToken = ctx.USDT.options.address; + var baseAmount = decimalStr("10000"); + var quoteAmount = mweiStr("10000"); + await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine( + project, + baseToken, + quoteToken, + baseAmount, + quoteAmount, + config.lpFeeRate, + config.mtFeeRate, + config.i, + config.k, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(project),"createDVM"); + var addrs = await ctx.DVMFactory.methods.getVendingMachine(baseToken,quoteToken).call(); + var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call(); + assert.equal( + dvmInfo[0], + project + ); + assert.equal( + await ctx.DODO.methods.balanceOf(addrs[1]).call(), + baseAmount + ); + assert.equal( + await ctx.USDT.methods.balanceOf(addrs[1]).call(), + quoteAmount + ); }); - /** - * 1. 移除ERC20 Amount - * 2. 移除ERC20 + ETH - */ - it("removeLiquidityToDVM", async () => { + it("createDVM - ETH", async () => { + var baseToken = '0x000000000000000000000000000000000000000E'; + var quoteToken = ctx.USDT.options.address; + var baseAmount = decimalStr("5"); + var quoteAmount = mweiStr("10000"); + await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine( + project, + baseToken, + quoteToken, + baseAmount, + quoteAmount, + config.lpFeeRate, + config.mtFeeRate, + config.i, + config.k, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(project, '5'),"createDVM - Wrap ETH"); + var addrs = await ctx.DVMFactory.methods.getVendingMachine(ctx.WETH.options.address,quoteToken).call(); + var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call(); + assert.equal( + dvmInfo[0], + project + ); + assert.equal( + await ctx.WETH.methods.balanceOf(addrs[1]).call(), + baseAmount + ); + assert.equal( + await ctx.USDT.methods.balanceOf(addrs[1]).call(), + quoteAmount + ); + }); + + it("addLiquidity", async () => { + var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call(); + var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call(); + var b_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call(); + assert.equal(b_baseReserve,decimalStr("100000")); + assert.equal(b_quoteReserve,mweiStr("30000")); + assert.equal(b_dlp,decimalStr("0")); + await logGas(await ctx.DODOProxy.methods.addDVMLiquidity( + dvm_DODO_USDT, + lp, + decimalStr("1000"), + mweiStr("300"), + decimalStr("0"), + mweiStr("0"), + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(lp),"addLiquidity"); + var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call(); + var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call(); + var a_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call(); + assert.equal(a_baseReserve,decimalStr("101000")); + assert.equal(a_quoteReserve,mweiStr("30300")); + assert.equal(a_dlp,"1000000000000000000000"); + }); + + + it("addLiquidity - ETH", async () => { + var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call(); + var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call(); + var b_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call(); + assert.equal(b_baseReserve,decimalStr("5")); + assert.equal(b_quoteReserve,mweiStr("30000")); + assert.equal(b_dlp,decimalStr("0")); + await logGas(await ctx.DODOProxy.methods.addDVMLiquidityETH( + dvm_WETH_USDT, + lp, + decimalStr("1"), + mweiStr("6000"), + decimalStr("0"), + mweiStr("0"), + 1, + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(lp,'1'),"addLiquidity - ETH"); + var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call(); + var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call(); + var a_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call(); + assert.equal(a_baseReserve,decimalStr("6")); + assert.equal(a_quoteReserve,mweiStr("36000")); + assert.equal(a_dlp,"1000000000000000000"); + }); + + //TODO:ing + it("removeLiquidity", async () => { + var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call(); + var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call(); + var b_dlp = await DVM_DODO_USDT.methods.balanceOf(project).call(); + assert.equal(b_baseReserve,decimalStr("100000")); + assert.equal(b_quoteReserve,mweiStr("30000")); + console.log("b_dlp:" + b_dlp); + // assert.equal(b_dlp,decimalStr("0")); + await logGas(await ctx.DODOProxy.methods.removeDVMLiquidity( + dvm_DODO_USDT, + project, + decimalStr("100"), + decimalStr("0"), + mweiStr("0"), + Math.floor(new Date().getTime()/1000 + 60 * 10) + ),ctx.sendParam(project),"removeLiquidity"); + var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call(); + var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call(); + var a_dlp = await DVM_DODO_USDT.methods.balanceOf(project).call(); + // assert.equal(a_baseReserve,decimalStr("6")); + // assert.equal(a_quoteReserve,mweiStr("36000")); + // assert.equal(a_dlp,"1000000000000000000"); + console.log("b_dlp:" + b_dlp + " a_dlp:" + a_dlp); + console.log("a_baseReserve:" + a_baseReserve + " a_quoteReserve:" + a_quoteReserve); }); /** @@ -112,10 +246,5 @@ describe("DODOProxyV2.0", () => { }); - - /** - * 直接底层dvm操作测试 - */ - }); }); diff --git a/test/utils/ProxyContext.ts b/test/utils/ProxyContext.ts index e9264ba..069a255 100644 --- a/test/utils/ProxyContext.ts +++ b/test/utils/ProxyContext.ts @@ -10,7 +10,7 @@ import Web3 from 'web3'; import { Contract } from 'web3-eth-contract'; import * as contracts from './Contracts'; -import { decimalStr, MAX_UINT256 } from './Converter'; +import { decimalStr, mweiStr, MAX_UINT256 } from './Converter'; import { EVM, getDefaultWeb3 } from './EVM'; import * as log from './Log'; @@ -63,7 +63,7 @@ export class ProxyContext { var permissionManagerTemplate = await contracts.newContract(contracts.PERMISSION_MANAGER_NAME) var vauleSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME) var defaultGasSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME) - await defaultGasSource.methods.init(this.Deployer,decimalStr("1000000")); + await defaultGasSource.methods.init(this.Deployer,MAX_UINT256).send(this.sendParam(this.Deployer)); this.DVMFactory = await contracts.newContract(contracts.DVM_FACTORY_NAME, [ @@ -125,7 +125,8 @@ export class ProxyContext { return { from: sender, gas: process.env["COVERAGE"] ? 10000000000 : 7000000, - gasPrice: process.env.GAS_PRICE, + // gasPrice: process.env.GAS_PRICE, + gasPrice: mweiStr("1000"), value: decimalStr(value), }; }