d-bis/dodo-contractV2
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
mingda
2020-11-11 23:48:50 +08:00
parent e4d6f42ef6 e792304358
commit 6d82f118f5
7 changed files with 388 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
contracts/SmartRoute/SmartSwap.sol
View File

@@ -12,8 +12,9 @@ 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 {IDODOSellHelper} from "../intf/IDODOSellHelper.sol";
import {ISmartApprove} from "../intf/ISmartApprove.sol";
import {IDODO} from "../intf/IDODO.sol";
contract SmartSwap is Ownable {
@@ -21,11 +22,11 @@ contract SmartSwap is Ownable {
using UniversalERC20 for IERC20;
using ExternalCall for address;
ISmartApprove public smartApprove;
IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
ISmartApprove public smartApprove;
IDODOSellHelper public dodoSellHelper;
event Swapped(
event OrderHistory(
IERC20 indexed fromToken,
IERC20 indexed toToken,
address indexed sender,
@@ -35,8 +36,9 @@ contract SmartSwap is Ownable {
event ExternalRecord(address indexed to, address indexed sender);
constructor(address _smartApprove) public {
constructor(address _smartApprove,address _dodoSellHelper) public {
smartApprove = ISmartApprove(_smartApprove);
dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
}
function dodoSwap(
@@ -44,40 +46,41 @@ contract SmartSwap is Ownable {
IERC20 toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory callPairs,
bytes memory callDataConcat,
uint256[] memory starts,
uint256[] memory gasLimitsAndValues
address[] memory dodoPairs,
uint256[] memory directions
) public payable returns (uint256 returnAmount) {
require(minReturnAmount > 0, "Min return should be bigger then 0.");
require(callPairs.length > 0, "pairs should exists.");
require(dodoPairs.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
),"Swap Transaction Error!"
);
for (uint256 i = 0; i < dodoPairs.length; i++) {
uint256 curDirection = directions[i];
address curDodoPair = dodoPairs[i];
if(curDirection == 0){
address curDodoBase = IDODO(curDodoPair)._BASE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this));
IERC20(curDodoBase).approve(curDodoPair,curAmountIn);
IDODO(curDodoPair).sellBaseToken(curAmountIn, 0, "");
}else {
address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
IERC20(curDodoQuote).approve(curDodoPair,curAmountIn);
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(curDodoPair,curAmountIn);
IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
}
}
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 OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
}
//TODO:change
function externalSwap(
IERC20 fromToken,
IERC20 toToken,
@@ -100,16 +103,12 @@ contract SmartSwap is Ownable {
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 OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
emit ExternalRecord(to, msg.sender);
}
}

226
contracts/helper/DODOSellHelper.sol Normal file
View File

@@ -0,0 +1,226 @@
/**
*Submitted for verification at Etherscan.io on 2020-10-10
*/
// File: contracts/intf/IDODO.sol
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {IDODO} from "../intf/IDODO.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {DecimalMath} from "../lib/DecimalMath.sol";
// import {DODOMath} from "../lib/DODOMath.sol";
library DODOMath {
using SafeMath for uint256;
/*
Integrate dodo curve fron V1 to V2
require V0>=V1>=V2>0
res = (1-k)i(V1-V2)+ikV0*V0(1/V2-1/V1)
let V1-V2=delta
res = i*delta*(1-k+k(V0^2/V1/V2))
*/
function _GeneralIntegrate(
uint256 V0,
uint256 V1,
uint256 V2,
uint256 i,
uint256 k
) internal pure returns (uint256) {
uint256 fairAmount = DecimalMath.mul(i, V1.sub(V2)); // i*delta
uint256 V0V0V1V2 = DecimalMath.divCeil(V0.mul(V0).div(V1), V2);
uint256 penalty = DecimalMath.mul(k, V0V0V1V2); // k(V0^2/V1/V2)
return DecimalMath.mul(fairAmount, DecimalMath.ONE.sub(k).add(penalty));
}
/*
The same with integration expression above, we have:
i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
Given Q1 and deltaB, solve Q2
This is a quadratic function and the standard version is
aQ2^2 + bQ2 + c = 0, where
a=1-k
-b=(1-k)Q1-kQ0^2/Q1+i*deltaB
c=-kQ0^2
and Q2=(-b+sqrt(b^2+4(1-k)kQ0^2))/2(1-k)
note: another root is negative, abondan
if deltaBSig=true, then Q2>Q1
if deltaBSig=false, then Q2<Q1
*/
function _SolveQuadraticFunctionForTrade(
uint256 Q0,
uint256 Q1,
uint256 ideltaB,
bool deltaBSig,
uint256 k
) internal pure returns (uint256) {
// calculate -b value and sig
// -b = (1-k)Q1-kQ0^2/Q1+i*deltaB
uint256 kQ02Q1 = DecimalMath.mul(k, Q0).mul(Q0).div(Q1); // kQ0^2/Q1
uint256 b = DecimalMath.mul(DecimalMath.ONE.sub(k), Q1); // (1-k)Q1
bool minusbSig = true;
if (deltaBSig) {
b = b.add(ideltaB); // (1-k)Q1+i*deltaB
} else {
kQ02Q1 = kQ02Q1.add(ideltaB); // i*deltaB+kQ0^2/Q1
}
if (b >= kQ02Q1) {
b = b.sub(kQ02Q1);
minusbSig = true;
} else {
b = kQ02Q1.sub(b);
minusbSig = false;
}
// calculate sqrt
uint256 squareRoot = DecimalMath.mul(
DecimalMath.ONE.sub(k).mul(4),
DecimalMath.mul(k, Q0).mul(Q0)
); // 4(1-k)kQ0^2
squareRoot = b.mul(b).add(squareRoot).sqrt(); // sqrt(b*b+4(1-k)kQ0*Q0)
// final res
uint256 denominator = DecimalMath.ONE.sub(k).mul(2); // 2(1-k)
uint256 numerator;
if (minusbSig) {
numerator = b.add(squareRoot);
} else {
numerator = squareRoot.sub(b);
}
if (deltaBSig) {
return DecimalMath.divFloor(numerator, denominator);
} else {
return DecimalMath.divCeil(numerator, denominator);
}
}
/*
Start from the integration function
i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
Assume Q2=Q0, Given Q1 and deltaB, solve Q0
let fairAmount = i*deltaB
*/
function _SolveQuadraticFunctionForTarget(
uint256 V1,
uint256 k,
uint256 fairAmount
) internal pure returns (uint256 V0) {
// V0 = V1+V1*(sqrt-1)/2k
uint256 sqrt = DecimalMath.divCeil(DecimalMath.mul(k, fairAmount).mul(4), V1);
sqrt = sqrt.add(DecimalMath.ONE).mul(DecimalMath.ONE).sqrt();
uint256 premium = DecimalMath.divCeil(sqrt.sub(DecimalMath.ONE), k.mul(2));
// V0 is greater than or equal to V1 according to the solution
return DecimalMath.mul(V1, DecimalMath.ONE.add(premium));
}
}
contract DODOSellHelper {
using SafeMath for uint256;
enum RStatus {ONE, ABOVE_ONE, BELOW_ONE}
uint256 constant ONE = 10**18;
struct DODOState {
uint256 oraclePrice;
uint256 K;
uint256 B;
uint256 Q;
uint256 baseTarget;
uint256 quoteTarget;
RStatus rStatus;
}
function querySellBaseToken(address dodo, uint256 amount) public view returns (uint256) {
return IDODO(dodo).querySellBaseToken(amount);
}
function querySellQuoteToken(address dodo, uint256 amount) public view returns (uint256) {
DODOState memory state;
(state.baseTarget, state.quoteTarget) = IDODO(dodo).getExpectedTarget();
state.rStatus = RStatus(IDODO(dodo)._R_STATUS_());
state.oraclePrice = IDODO(dodo).getOraclePrice();
state.Q = IDODO(dodo)._QUOTE_BALANCE_();
state.B = IDODO(dodo)._BASE_BALANCE_();
state.K = IDODO(dodo)._K_();
uint256 boughtAmount;
// Determine the status (RStatus) and calculate the amount
// based on the state
if (state.rStatus == RStatus.ONE) {
boughtAmount = _ROneSellQuoteToken(amount, state);
} else if (state.rStatus == RStatus.ABOVE_ONE) {
boughtAmount = _RAboveSellQuoteToken(amount, state);
} else {
uint256 backOneBase = state.B.sub(state.baseTarget);
uint256 backOneQuote = state.quoteTarget.sub(state.Q);
if (amount <= backOneQuote) {
boughtAmount = _RBelowSellQuoteToken(amount, state);
} else {
boughtAmount = backOneBase.add(
_ROneSellQuoteToken(amount.sub(backOneQuote), state)
);
}
}
// Calculate fees
return
DecimalMath.divFloor(
boughtAmount,
DecimalMath.ONE.add(IDODO(dodo)._MT_FEE_RATE_()).add(IDODO(dodo)._LP_FEE_RATE_())
);
}
function _ROneSellQuoteToken(uint256 amount, DODOState memory state)
internal
pure
returns (uint256 receiveBaseToken)
{
uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
uint256 B2 = DODOMath._SolveQuadraticFunctionForTrade(
state.baseTarget,
state.baseTarget,
DecimalMath.mul(i, amount),
false,
state.K
);
return state.baseTarget.sub(B2);
}
function _RAboveSellQuoteToken(uint256 amount, DODOState memory state)
internal
pure
returns (uint256 receieBaseToken)
{
uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
uint256 B2 = DODOMath._SolveQuadraticFunctionForTrade(
state.baseTarget,
state.B,
DecimalMath.mul(i, amount),
false,
state.K
);
return state.B.sub(B2);
}
function _RBelowSellQuoteToken(uint256 amount, DODOState memory state)
internal
pure
returns (uint256 receiveBaseToken)
{
uint256 Q1 = state.Q.add(amount);
uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
return DODOMath._GeneralIntegrate(state.quoteTarget, Q1, state.Q, i, state.K);
}
}

81
contracts/intf/IDODO.sol Normal file
View File

@@ -0,0 +1,81 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IDODO {
function init(
address owner,
address supervisor,
address maintainer,
address baseToken,
address quoteToken,
address oracle,
uint256 lpFeeRate,
uint256 mtFeeRate,
uint256 k,
uint256 gasPriceLimit
) external;
function transferOwnership(address newOwner) external;
function claimOwnership() external;
function sellBaseToken(
uint256 amount,
uint256 minReceiveQuote,
bytes calldata data
) external returns (uint256);
function buyBaseToken(
uint256 amount,
uint256 maxPayQuote,
bytes calldata data
) external returns (uint256);
function querySellBaseToken(uint256 amount) external view returns (uint256 receiveQuote);
function queryBuyBaseToken(uint256 amount) external view returns (uint256 payQuote);
function depositBaseTo(address to, uint256 amount) external returns (uint256);
function withdrawBase(uint256 amount) external returns (uint256);
function withdrawAllBase() external returns (uint256);
function depositQuoteTo(address to, uint256 amount) external returns (uint256);
function withdrawQuote(uint256 amount) external returns (uint256);
function withdrawAllQuote() external returns (uint256);
function _BASE_CAPITAL_TOKEN_() external returns (address);
function _QUOTE_CAPITAL_TOKEN_() external returns (address);
function _BASE_TOKEN_() external returns (address);
function _QUOTE_TOKEN_() external returns (address);
function _R_STATUS_() external view returns (uint8);
function _QUOTE_BALANCE_() external view returns (uint256);
function _BASE_BALANCE_() external view returns (uint256);
function _K_() external view returns (uint256);
function _MT_FEE_RATE_() external view returns (uint256);
function _LP_FEE_RATE_() external view returns (uint256);
function getExpectedTarget() external view returns (uint256 baseTarget, uint256 quoteTarget);
function getOraclePrice() external view returns (uint256);
}

14
contracts/intf/IDODOSellHelper.sol Normal file
View File

@@ -0,0 +1,14 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IDODOSellHelper {
function querySellQuoteToken(address dodo, uint256 amount) external view returns (uint256);
function querySellBaseToken(address dodo, uint256 amount) external view returns (uint256);
}

111
test/Route/Route.test.ts
View File

@@ -48,7 +48,6 @@ async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
await ctx.approvePair(USDT,USDC,USDT_USDC.options.address,lp);
await ctx.mintToken(USDT,USDC,lp, mweiStr("1000"), mweiStr("1000"));
await ctx.mintToken(USDT,USDC,trader, mweiStr("0"), mweiStr("0"));
await USDT_USDC.methods
.depositBaseTo(lp, mweiStr("1000"))
@@ -58,6 +57,7 @@ async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
.send(ctx.sendParam(lp));
}
async function initWETH_USDC(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE,mweiStr("450"));
lp = ctx.spareAccounts[0];
@@ -81,77 +81,38 @@ async function initWETH_USDC(ctx: DODOContext): Promise<void> {
//mock sdk logic
async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number,routes:any[],pairs:any[]) {
let swapAmount = fromTokenAmount
let directions:number[] = []
let dodoPairs:string[] = []
let callPairs: string[] = []
let datas: string = ""
let starts: number[] = []
let gAndV: number[] = []
for (let i = 0; i < pairs.length; i++) {
if(i == 0){
starts.push(0);
}
let curPair = pairs[i]
let curContact =pairs[i].pairContract;
let curData = '';
let curApproveData = '';
dodoPairs.push(curPair.pair)
let curContact = pairs[i].pairContract
if (curPair.base === routes[i].address) {
curApproveData = await pairs[i].baseContract.methods.approve(curPair.pair,swapAmount).encodeABI()
curApproveData = curApproveData.substring(2,curApproveData.length)
datas += curApproveData
starts.push(datas.length/2)
gAndV.push(0)
callPairs.push(pairs[i].baseContract.options.address);
curData = await curContact.methods.sellBaseToken(swapAmount, 0, "0x").encodeABI()
console.log(i + ":b-for-swapAmount:",swapAmount);
directions[i] = 0;
swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
console.log(i + ":a-for-swapAmount:",swapAmount);
console.log(i + "-swapAmount:",swapAmount);
} else {
curApproveData = await pairs[i].quoteContract.methods.approve(curPair.pair,swapAmount).encodeABI()
curApproveData = curApproveData.substring(2,curApproveData.length)
datas += curApproveData
starts.push(datas.length/2)
gAndV.push(0)
callPairs.push(pairs[i].quoteContract.options.address);
console.log(i + ":b-for-swapAmount:",swapAmount);
let baseDecimal = await pairs[i].baseContract.methods.decimals().call();
let quoteDecimal = await pairs[i].quoteContract.methods.decimals().call();
let curPairDetail = {
B: new BigNumber(await curContact.methods._BASE_BALANCE_().call() / 10 ** baseDecimal),
Q: new BigNumber(await curContact.methods._QUOTE_BALANCE_().call() / 10 ** quoteDecimal),
B0: new BigNumber(await curContact.methods._TARGET_BASE_TOKEN_AMOUNT_().call() / 10 ** baseDecimal),
Q0: new BigNumber(await curContact.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call() / 10 ** quoteDecimal),
RStatus: await curContact.methods._R_STATUS_().call(),
OraclePrice: new BigNumber(await curContact.methods.getOraclePrice().call() / 10 ** (18-baseDecimal + quoteDecimal)),
k: new BigNumber(parseInt(ctx.k) / 1e18),
mtFeeRate: new BigNumber(parseInt(ctx.mtFeeRate) / 1e18),
lpFeeRate: new BigNumber(parseInt(ctx.lpFeeRate) / 1e18)
}
let dodoHelper = new DODOHelper(curPairDetail)
//TODO:2倍？
let tmpQuoteAmount = new BigNumber(swapAmount).multipliedBy(1-0.006).toFixed(0, BigNumber.ROUND_DOWN)
let tmpBaseAmount = dodoHelper.queryBuyQuote(new BigNumber(fromWei(tmpQuoteAmount,'mwei'))).toString();
curData = await curContact.methods.buyBaseToken(decimalStr(tmpBaseAmount), swapAmount, "0x").encodeABI()
swapAmount = decimalStr(tmpBaseAmount);
console.log(i + ":a-for-swapAmount:",swapAmount);
directions[i] = 1;
swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair,swapAmount).call();
console.log(i + "-swapAmount:",swapAmount);
}
curData = curData.substring(2,curData.length)
datas += curData
starts.push(datas.length/2)
gAndV.push(0)
callPairs.push(curPair.pair)
}
datas = "0x" + datas;
let toAmount = new BigNumber(swapAmount).multipliedBy(1-slippage).toFixed(0, BigNumber.ROUND_DOWN)
console.log("minAmount:",toAmount);
// console.log("dodoPairs",dodoPairs);
// console.log("directions",directions);
return ctx.SmartSwap.methods.dodoSwap(
routes[0].address,
routes[routes.length-1].address,
fromTokenAmount,
toAmount,
callPairs,
datas,
starts,
gAndV
dodoPairs,
directions
)
}
@@ -195,14 +156,12 @@ describe("Trader", () => {
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT,
baseContract: ctx.DODO,
quoteContract: ctx.USDT
pairContract: ctx.DODO_USDT
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route swap")
// console.log(tx.events['Swapped']);
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "directly swap")
// console.log(tx.events['OrderHistory']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO,'ether') + "; USDT:" + fromWei(a_USDT,'mwei'));
@@ -235,21 +194,17 @@ describe("Trader", () => {
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT,
baseContract: ctx.DODO,
quoteContract: ctx.USDT
pairContract: ctx.DODO_USDT
/**************/
},{
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
/*only for test*/
pairContract: ctx.USDT_USDC,
baseContract: ctx.USDT,
quoteContract: ctx.USDC
pairContract: ctx.USDT_USDC
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route swap")
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "tow hops swap")
// console.log(tx.events['Swapped']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_USDC = await ctx.USDC.methods.balanceOf(trader).call()
@@ -286,30 +241,24 @@ describe("Trader", () => {
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT,
baseContract: ctx.DODO,
quoteContract: ctx.USDT
pairContract: ctx.DODO_USDT
/**************/
},{
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
/*only for test*/
pairContract: ctx.USDT_USDC,
baseContract: ctx.USDT,
quoteContract: ctx.USDC
pairContract: ctx.USDT_USDC
/**************/
},{
pair: ctx.WETH_USDC.options.address,
base: ctx.WETH.options.address,
/*only for test*/
pairContract: ctx.WETH_USDC,
baseContract: ctx.WETH,
quoteContract: ctx.USDC
pairContract: ctx.WETH_USDC
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route swap")
// console.log(tx.events['Swapped']);
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "three hops swap")
console.log(tx.events['TestAmount']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO,'ether') + "; WETH:" + fromWei(a_WETH,'ether'));

8
test/utils-v1/Context-route.ts
View File

@@ -57,7 +57,6 @@ export class DODOContext {
lpFeeRate: string;
mtFeeRate: string;
k: string;
//token
DODO:Contract;
USDT:Contract;
@@ -73,6 +72,7 @@ export class DODOContext {
//SmartRoute
SmartSwap: Contract;
SmartApprove: Contract;
DODOSellHelper: Contract;
constructor() {}
@@ -213,13 +213,17 @@ export class DODOContext {
.send(this.sendParam(this.Deployer));
await this.WETH_USDC.methods.enableTrading().send(this.sendParam(this.Deployer));
this.DODOSellHelper = await contracts.newContract(
contracts.DODO_SELL_HELPER
);
this.SmartApprove = await contracts.newContract(
contracts.SMART_APPROVE
);
this.SmartSwap = await contracts.newContract(
contracts.SMART_SWAP,
[this.SmartApprove.options.address]
[this.SmartApprove.options.address,this.DODOSellHelper.options.address]
);
await this.SmartApprove.methods.setSmartSwap(this.SmartSwap.options.address).send(this.sendParam(this.Deployer));

3
test/utils-v1/Contracts.ts
View File

@@ -30,6 +30,7 @@ const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`)
/*v1.5*/
const SmartSwap = require(`${jsonPath2}SmartSwap.json`)
const SmartApprove = require(`${jsonPath2}SmartApprove.json`)
const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`)
/******/
import { getDefaultWeb3 } from './EVM';
@@ -53,6 +54,7 @@ export const DODO_MINE_READER_NAME = "DODOMineReader"
/*v1.5*/
export const SMART_SWAP = "SmartSwap"
export const SMART_APPROVE = "SmartApprove"
export const DODO_SELL_HELPER = "DODOSellHelper"
/******/
var contractMap: { [name: string]: any } = {}
@@ -73,6 +75,7 @@ contractMap[DODO_MINE_READER_NAME] = DODOMineReader
/*v1.5*/
contractMap[SMART_SWAP] = SmartSwap
contractMap[SMART_APPROVE] = SmartApprove
contractMap[DODO_SELL_HELPER] = DODOSellHelper
/******/
interface ContractJson {