bsc trade incentive
This commit is contained in:
owen05
99
contracts/DODOToken/DODOIncentiveBsc.sol
Normal file
99
contracts/DODOToken/DODOIncentiveBsc.sol
Normal file
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
|
||||
Copyright 2020 DODO ZOO.
|
||||
SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
*/
|
||||
|
||||
pragma solidity 0.6.9;
|
||||
|
||||
import {InitializableOwnable} from "../lib/InitializableOwnable.sol";
|
||||
import {ILockedTokenVault02} from "../intf/ILockedTokenVault02.sol";
|
||||
import {SafeERC20} from "../lib/SafeERC20.sol";
|
||||
import {SafeMath} from "../lib/SafeMath.sol";
|
||||
import {IERC20} from "../intf/IERC20.sol";
|
||||
|
||||
/**
|
||||
* @title DODOIncentiveBsc
|
||||
* @author DODO Breeder
|
||||
*
|
||||
* @notice Trade Incentive in DODO platform
|
||||
*/
|
||||
contract DODOIncentiveBsc is InitializableOwnable {
|
||||
using SafeMath for uint256;
|
||||
using SafeERC20 for IERC20;
|
||||
|
||||
// ============ Storage ============
|
||||
address public immutable _DODO_TOKEN_;
|
||||
address public _DODO_PROXY_;
|
||||
address public _LOCKED_VAULT_;
|
||||
|
||||
mapping(address => bool) public stableList;
|
||||
mapping(address => bool) public tokenList; //Not include stable tokens
|
||||
uint256 public baseAmount = 1000;
|
||||
uint256 public baseReward = 10**18;
|
||||
|
||||
// ============ Events ============
|
||||
|
||||
event SetStableList(address token, bool isUse);
|
||||
event SetTokenList(address token, bool isUse);
|
||||
event SetBaseAmount(uint256 baseAmount);
|
||||
event SetBaseReward(uint256 baseReward);
|
||||
|
||||
event Incentive(address user, uint256 reward);
|
||||
|
||||
constructor(address _dodoToken) public {
|
||||
_DODO_TOKEN_ = _dodoToken;
|
||||
}
|
||||
|
||||
// ============ Ownable ============
|
||||
|
||||
function setContract(address dodoProxy,address lockedVault) external onlyOwner {
|
||||
_DODO_PROXY_ = dodoProxy;
|
||||
_LOCKED_VAULT_ = lockedVault;
|
||||
}
|
||||
|
||||
function setStableList(address token, bool isUse) external onlyOwner {
|
||||
require(token != address(0));
|
||||
stableList[token] = isUse;
|
||||
emit SetStableList(token, isUse);
|
||||
}
|
||||
|
||||
function setTokenList(address token, bool isUse) external onlyOwner {
|
||||
require(token != address(0));
|
||||
tokenList[token] = isUse;
|
||||
emit SetTokenList(token, isUse);
|
||||
}
|
||||
|
||||
function changeBaseAmount(uint256 newBaseAmount) external onlyOwner {
|
||||
baseAmount = newBaseAmount;
|
||||
emit SetBaseAmount(newBaseAmount);
|
||||
}
|
||||
|
||||
function changeBaseReward(uint256 newBaseReward) external onlyOwner {
|
||||
baseReward = newBaseReward;
|
||||
emit SetBaseAmount(newBaseReward);
|
||||
}
|
||||
|
||||
// ============ Incentive function ============
|
||||
|
||||
function triggerIncentive(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
uint256 fromAmount,
|
||||
uint256 returnAmount,
|
||||
address assetTo
|
||||
) external {
|
||||
require(msg.sender == _DODO_PROXY_, "DODOIncentiveBsc:Access restricted");
|
||||
uint256 reward = 0;
|
||||
if(stableList[fromToken] && tokenList[toToken]) {
|
||||
reward = fromAmount.div(baseAmount);
|
||||
} else if (stableList[toToken] && tokenList[fromToken]) {
|
||||
reward = returnAmount.div(baseAmount);
|
||||
}
|
||||
if (reward != 0) {
|
||||
ILockedTokenVault02(_LOCKED_VAULT_).tradeIncentive(assetTo,reward);
|
||||
emit Incentive(assetTo, reward);
|
||||
}
|
||||
}
|
||||
}
|
||||
196
contracts/DODOToken/LockedTokenVault02.sol
Normal file
196
contracts/DODOToken/LockedTokenVault02.sol
Normal file
@@ -0,0 +1,196 @@
|
||||
/*
|
||||
|
||||
Copyright 2020 DODO ZOO.
|
||||
SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
*/
|
||||
|
||||
pragma solidity 0.6.9;
|
||||
pragma experimental ABIEncoderV2;
|
||||
|
||||
import {InitializableOwnable} from "../lib/InitializableOwnable.sol";
|
||||
import {SafeMath} from "../lib/SafeMath.sol";
|
||||
import {DecimalMath} from "../lib/DecimalMath.sol";
|
||||
import {SafeERC20} from "../lib/SafeERC20.sol";
|
||||
import {IERC20} from "../intf/IERC20.sol";
|
||||
|
||||
/**
|
||||
* @title LockedTokenVault02
|
||||
* @author DODO Breeder
|
||||
*
|
||||
* @notice Lock Token and release it linearly
|
||||
*/
|
||||
|
||||
contract LockedTokenVault02 is InitializableOwnable {
|
||||
using SafeMath for uint256;
|
||||
using SafeERC20 for IERC20;
|
||||
|
||||
address _TOKEN_;
|
||||
address public _DODO_INCENTIVE_;
|
||||
|
||||
mapping(address => uint256) internal originBalances;
|
||||
mapping(address => uint256) internal claimedBalances;
|
||||
|
||||
// uint256 public _UNDISTRIBUTED_AMOUNT_;
|
||||
uint256 public _START_RELEASE_TIME_;
|
||||
uint256 public _RELEASE_DURATION_;
|
||||
uint256 public _CLIFF_RATE_;
|
||||
|
||||
bool public _DISTRIBUTE_FINISHED_;
|
||||
|
||||
// ============ Events ============
|
||||
|
||||
event Claim(address indexed holder, uint256 origin, uint256 claimed, uint256 amount);
|
||||
|
||||
// ============ Modifiers ============
|
||||
|
||||
modifier beforeStartRelease() {
|
||||
require(block.timestamp < _START_RELEASE_TIME_, "RELEASE START");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier afterStartRelease() {
|
||||
require(block.timestamp >= _START_RELEASE_TIME_, "RELEASE NOT START");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier distributeNotFinished() {
|
||||
require(!_DISTRIBUTE_FINISHED_, "DISTRIBUTE FINISHED");
|
||||
_;
|
||||
}
|
||||
|
||||
// ============ Init Functions ============
|
||||
|
||||
constructor(
|
||||
address _token,
|
||||
uint256 _startReleaseTime,
|
||||
uint256 _releaseDuration,
|
||||
uint256 _cliffRate
|
||||
) public {
|
||||
_TOKEN_ = _token;
|
||||
_START_RELEASE_TIME_ = _startReleaseTime;
|
||||
_RELEASE_DURATION_ = _releaseDuration;
|
||||
_CLIFF_RATE_ = _cliffRate;
|
||||
}
|
||||
|
||||
function updateParams(uint256 startReleaseTime, uint256 releaseDuration, uint256 cliffRate) external onlyOwner {
|
||||
_START_RELEASE_TIME_ = startReleaseTime;
|
||||
_RELEASE_DURATION_ = releaseDuration;
|
||||
_CLIFF_RATE_ = cliffRate;
|
||||
}
|
||||
|
||||
function deposit(uint256 amount) external onlyOwner {
|
||||
_tokenTransferIn(_OWNER_, amount);
|
||||
// _UNDISTRIBUTED_AMOUNT_ = _UNDISTRIBUTED_AMOUNT_.add(amount);
|
||||
}
|
||||
|
||||
function withdraw(uint256 amount) external onlyOwner {
|
||||
// _UNDISTRIBUTED_AMOUNT_ = _UNDISTRIBUTED_AMOUNT_.sub(amount);
|
||||
_tokenTransferOut(_OWNER_, amount);
|
||||
}
|
||||
|
||||
function finishDistribute() external onlyOwner {
|
||||
_DISTRIBUTE_FINISHED_ = true;
|
||||
}
|
||||
|
||||
// ============ For DODOIncentiveBsc ===========
|
||||
|
||||
function tradeIncentive(address trader, uint256 amount) external {
|
||||
require(_DODO_INCENTIVE_ == msg.sender, "LockedTokenVault02:Access restricted");
|
||||
originBalances[trader] = originBalances[trader].add(amount);
|
||||
// _UNDISTRIBUTED_AMOUNT_ = _UNDISTRIBUTED_AMOUNT_.sub(amount);
|
||||
}
|
||||
|
||||
// ================== For Owner ================
|
||||
|
||||
function grant(address[] calldata holderList, uint256[] calldata amountList)
|
||||
external
|
||||
onlyOwner
|
||||
{
|
||||
require(holderList.length == amountList.length, "batch grant length not match");
|
||||
uint256 amount = 0;
|
||||
for (uint256 i = 0; i < holderList.length; ++i) {
|
||||
// for saving gas, no event for grant
|
||||
originBalances[holderList[i]] = originBalances[holderList[i]].add(amountList[i]);
|
||||
amount = amount.add(amountList[i]);
|
||||
}
|
||||
// _UNDISTRIBUTED_AMOUNT_ = _UNDISTRIBUTED_AMOUNT_.sub(amount);
|
||||
}
|
||||
|
||||
function recall(address holder) external onlyOwner distributeNotFinished {
|
||||
// _UNDISTRIBUTED_AMOUNT_ = _UNDISTRIBUTED_AMOUNT_.add(originBalances[holder]).sub(
|
||||
// claimedBalances[holder]
|
||||
// );
|
||||
originBalances[holder] = 0;
|
||||
claimedBalances[holder] = 0;
|
||||
}
|
||||
|
||||
// ============ For Holder ============
|
||||
|
||||
function transferLockedToken(address to) external {
|
||||
originBalances[to] = originBalances[to].add(originBalances[msg.sender]);
|
||||
claimedBalances[to] = claimedBalances[to].add(claimedBalances[msg.sender]);
|
||||
|
||||
originBalances[msg.sender] = 0;
|
||||
claimedBalances[msg.sender] = 0;
|
||||
}
|
||||
|
||||
function claim() external {
|
||||
uint256 claimableToken = getClaimableBalance(msg.sender);
|
||||
_tokenTransferOut(msg.sender, claimableToken);
|
||||
claimedBalances[msg.sender] = claimedBalances[msg.sender].add(claimableToken);
|
||||
emit Claim(
|
||||
msg.sender,
|
||||
originBalances[msg.sender],
|
||||
claimedBalances[msg.sender],
|
||||
claimableToken
|
||||
);
|
||||
}
|
||||
|
||||
// ============ View ============
|
||||
|
||||
function isReleaseStart() external view returns (bool) {
|
||||
return block.timestamp >= _START_RELEASE_TIME_;
|
||||
}
|
||||
|
||||
function getOriginBalance(address holder) external view returns (uint256) {
|
||||
return originBalances[holder];
|
||||
}
|
||||
|
||||
function getClaimedBalance(address holder) external view returns (uint256) {
|
||||
return claimedBalances[holder];
|
||||
}
|
||||
|
||||
function getClaimableBalance(address holder) public view returns (uint256) {
|
||||
uint256 remainingToken = getRemainingBalance(holder);
|
||||
return originBalances[holder].sub(remainingToken).sub(claimedBalances[holder]);
|
||||
}
|
||||
|
||||
function getRemainingBalance(address holder) public view returns (uint256) {
|
||||
uint256 remainingRatio = getRemainingRatio(block.timestamp);
|
||||
return DecimalMath.mulFloor(originBalances[holder], remainingRatio);
|
||||
}
|
||||
|
||||
function getRemainingRatio(uint256 timestamp) public view returns (uint256) {
|
||||
if (timestamp < _START_RELEASE_TIME_) {
|
||||
return DecimalMath.ONE;
|
||||
}
|
||||
uint256 timePast = timestamp.sub(_START_RELEASE_TIME_);
|
||||
if (timePast < _RELEASE_DURATION_) {
|
||||
uint256 remainingTime = _RELEASE_DURATION_.sub(timePast);
|
||||
return DecimalMath.ONE.sub(_CLIFF_RATE_).mul(remainingTime).div(_RELEASE_DURATION_);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// ============ Internal Helper ============
|
||||
|
||||
function _tokenTransferIn(address from, uint256 amount) internal {
|
||||
IERC20(_TOKEN_).safeTransferFrom(from, address(this), amount);
|
||||
}
|
||||
|
||||
function _tokenTransferOut(address to, uint256 amount) internal {
|
||||
IERC20(_TOKEN_).safeTransfer(to, amount);
|
||||
}
|
||||
}
|
||||
@@ -91,6 +91,6 @@ contract DVM is DVMTrader, DVMFunding {
|
||||
// ============ Version Control ============
|
||||
|
||||
function version() external pure returns (string memory) {
|
||||
return "DVM 1.0.0";
|
||||
return "DVM 1.0.1";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -33,11 +33,9 @@ contract UpCrowdPoolingFactory is InitializableOwnable {
|
||||
address public _CP_TEMPLATE_;
|
||||
|
||||
// ============ Settings =============
|
||||
|
||||
uint256 public _FREEZE_DURATION_ = 30 days;
|
||||
uint256 public _CALM_DURATION_ = 0;
|
||||
uint256 public _VEST_DURATION_ = 0;
|
||||
uint256 public _K_ = 0;
|
||||
uint256 public _CLIFF_RATE_ = 10**18;
|
||||
|
||||
|
||||
@@ -56,11 +54,10 @@ contract UpCrowdPoolingFactory is InitializableOwnable {
|
||||
uint256[] memory timeLine,
|
||||
uint256[] memory valueList)
|
||||
{
|
||||
require(timeLine[2] == _CALM_DURATION_, "CP_FACTORY : PHASE_CALM_DURATION_INVALID");
|
||||
require(timeLine[2] <= _CALM_DURATION_, "CP_FACTORY : PHASE_CALM_DURATION_INVALID");
|
||||
require(timeLine[4] == _VEST_DURATION_, "CP_FACTORY : VEST_DURATION_INVALID");
|
||||
require(valueList[1] == _K_, "CP_FACTORY : K_INVALID");
|
||||
require(valueList[3] == _CLIFF_RATE_, "CP_FACTORY : CLIFF_RATE_INVALID");
|
||||
require(timeLine[3]>= _FREEZE_DURATION_, "CP_FACTORY : FREEZE_DURATION_INVALID");
|
||||
require(timeLine[3] >= _FREEZE_DURATION_, "CP_FACTORY : FREEZE_DURATION_INVALID");
|
||||
_;
|
||||
}
|
||||
|
||||
@@ -174,11 +171,6 @@ contract UpCrowdPoolingFactory is InitializableOwnable {
|
||||
_VEST_DURATION_ = _newVestDuration;
|
||||
}
|
||||
|
||||
function setK(uint256 _newK) public onlyOwner {
|
||||
require(_newK <= 10**18, "CP_FACTORY : INVALID");
|
||||
_K_ = _newK;
|
||||
}
|
||||
|
||||
function setCliffRate(uint256 _newCliffRate) public onlyOwner {
|
||||
require(_newCliffRate <= 10**18, "CP_FACTORY : INVALID");
|
||||
_CLIFF_RATE_ = _newCliffRate;
|
||||
|
||||
811
contracts/SmartRoute/DODOV2Proxy03Bsc.sol
Normal file
811
contracts/SmartRoute/DODOV2Proxy03Bsc.sol
Normal file
@@ -0,0 +1,811 @@
|
||||
/*
|
||||
|
||||
Copyright 2020 DODO ZOO.
|
||||
SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
*/
|
||||
|
||||
pragma solidity 0.6.9;
|
||||
|
||||
import {IDODOV2Proxy01} from "./intf/IDODOV2Proxy01.sol";
|
||||
import {IDODOV2} from "./intf/IDODOV2.sol";
|
||||
import {IDODOV1} from "./intf/IDODOV1.sol";
|
||||
import {IDODOApproveProxy} from "./DODOApproveProxy.sol";
|
||||
import {IDODOSellHelper} from "./helper/DODOSellHelper.sol";
|
||||
import {IERC20} from "../intf/IERC20.sol";
|
||||
import {IWETH} from "../intf/IWETH.sol";
|
||||
import {IUni} from "./intf/IUni.sol";
|
||||
import {IChi} from "./intf/IChi.sol";
|
||||
import {SafeMath} from "../lib/SafeMath.sol";
|
||||
import {UniversalERC20} from "./lib/UniversalERC20.sol";
|
||||
import {SafeERC20} from "../lib/SafeERC20.sol";
|
||||
import {DecimalMath} from "../lib/DecimalMath.sol";
|
||||
import {ReentrancyGuard} from "../lib/ReentrancyGuard.sol";
|
||||
import {InitializableOwnable} from "../lib/InitializableOwnable.sol";
|
||||
import {IDODOIncentiveBsc} from "../intf/IDODOIncentiveBsc.sol";
|
||||
import {IDODOAdapter} from "./intf/IDODOAdapter.sol";
|
||||
|
||||
/**
|
||||
* @title DODOV2Proxy03Bsc
|
||||
* @author DODO Breeder
|
||||
*
|
||||
* @notice Entrance of trading in DODO platform
|
||||
*/
|
||||
contract DODOV2Proxy03Bsc is IDODOV2Proxy01, ReentrancyGuard, InitializableOwnable {
|
||||
using SafeMath for uint256;
|
||||
using UniversalERC20 for IERC20;
|
||||
|
||||
// ============ Storage ============
|
||||
|
||||
address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
|
||||
address public immutable _WETH_;
|
||||
address public immutable _DODO_APPROVE_PROXY_;
|
||||
address public immutable _DODO_SELL_HELPER_;
|
||||
address public immutable _DVM_FACTORY_;
|
||||
address public immutable _DPP_FACTORY_;
|
||||
address public immutable _CP_FACTORY_;
|
||||
address public immutable _CHI_TOKEN_;
|
||||
uint256 public _GAS_DODO_MAX_RETURN_ = 0;
|
||||
uint256 public _GAS_EXTERNAL_RETURN_ = 0;
|
||||
|
||||
address public _DODO_INCENTIVE_;
|
||||
mapping (address => bool) public isWhiteListed;
|
||||
|
||||
// ============ Events ============
|
||||
|
||||
event OrderHistory(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
address sender,
|
||||
uint256 fromAmount,
|
||||
uint256 returnAmount
|
||||
);
|
||||
|
||||
// ============ Modifiers ============
|
||||
|
||||
modifier judgeExpired(uint256 deadLine) {
|
||||
require(deadLine >= block.timestamp, "DODOV2Proxy03Bsc: EXPIRED");
|
||||
_;
|
||||
}
|
||||
|
||||
fallback() external payable {}
|
||||
|
||||
receive() external payable {}
|
||||
|
||||
constructor(
|
||||
address dvmFactory,
|
||||
address dppFactory,
|
||||
address cpFactory,
|
||||
address payable weth,
|
||||
address dodoApproveProxy,
|
||||
address dodoSellHelper,
|
||||
address chiToken,
|
||||
address dodoIncentive
|
||||
) public {
|
||||
_DVM_FACTORY_ = dvmFactory;
|
||||
_DPP_FACTORY_ = dppFactory;
|
||||
_CP_FACTORY_ = cpFactory;
|
||||
_WETH_ = weth;
|
||||
_DODO_APPROVE_PROXY_ = dodoApproveProxy;
|
||||
_DODO_SELL_HELPER_ = dodoSellHelper;
|
||||
_CHI_TOKEN_ = chiToken;
|
||||
_DODO_INCENTIVE_ = dodoIncentive;
|
||||
}
|
||||
|
||||
function addWhiteList (address contractAddr) public onlyOwner {
|
||||
isWhiteListed[contractAddr] = true;
|
||||
}
|
||||
|
||||
function removeWhiteList (address contractAddr) public onlyOwner {
|
||||
isWhiteListed[contractAddr] = false;
|
||||
}
|
||||
|
||||
function updateDodoIncentive (address newDodoIncentive) public onlyOwner {
|
||||
_DODO_INCENTIVE_ = newDodoIncentive;
|
||||
}
|
||||
|
||||
function updateGasReturn(uint256 newDodoGasReturn, uint256 newExternalGasReturn) public onlyOwner {
|
||||
_GAS_DODO_MAX_RETURN_ = newDodoGasReturn;
|
||||
_GAS_EXTERNAL_RETURN_ = newExternalGasReturn;
|
||||
}
|
||||
|
||||
// ============ DVM Functions (create & add liquidity) ============
|
||||
|
||||
function createDODOVendingMachine(
|
||||
address baseToken,
|
||||
address quoteToken,
|
||||
uint256 baseInAmount,
|
||||
uint256 quoteInAmount,
|
||||
uint256 lpFeeRate,
|
||||
uint256 i,
|
||||
uint256 k,
|
||||
bool isOpenTWAP,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
preventReentrant
|
||||
judgeExpired(deadLine)
|
||||
returns (address newVendingMachine, uint256 shares)
|
||||
{
|
||||
{
|
||||
address _baseToken = baseToken == _ETH_ADDRESS_ ? _WETH_ : baseToken;
|
||||
address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken;
|
||||
newVendingMachine = IDODOV2(_DVM_FACTORY_).createDODOVendingMachine(
|
||||
_baseToken,
|
||||
_quoteToken,
|
||||
lpFeeRate,
|
||||
i,
|
||||
k,
|
||||
isOpenTWAP
|
||||
);
|
||||
}
|
||||
|
||||
{
|
||||
address _baseToken = baseToken;
|
||||
address _quoteToken = quoteToken;
|
||||
_deposit(
|
||||
msg.sender,
|
||||
newVendingMachine,
|
||||
_baseToken,
|
||||
baseInAmount,
|
||||
_baseToken == _ETH_ADDRESS_
|
||||
);
|
||||
_deposit(
|
||||
msg.sender,
|
||||
newVendingMachine,
|
||||
_quoteToken,
|
||||
quoteInAmount,
|
||||
_quoteToken == _ETH_ADDRESS_
|
||||
);
|
||||
}
|
||||
|
||||
(shares, , ) = IDODOV2(newVendingMachine).buyShares(msg.sender);
|
||||
}
|
||||
|
||||
function addDVMLiquidity(
|
||||
address dvmAddress,
|
||||
uint256 baseInAmount,
|
||||
uint256 quoteInAmount,
|
||||
uint256 baseMinAmount,
|
||||
uint256 quoteMinAmount,
|
||||
uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
preventReentrant
|
||||
judgeExpired(deadLine)
|
||||
returns (
|
||||
uint256 shares,
|
||||
uint256 baseAdjustedInAmount,
|
||||
uint256 quoteAdjustedInAmount
|
||||
)
|
||||
{
|
||||
address _dvm = dvmAddress;
|
||||
(baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(
|
||||
_dvm,
|
||||
baseInAmount,
|
||||
quoteInAmount
|
||||
);
|
||||
require(
|
||||
baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
|
||||
"DODOV2Proxy03Bsc: deposit amount is not enough"
|
||||
);
|
||||
|
||||
_deposit(msg.sender, _dvm, IDODOV2(_dvm)._BASE_TOKEN_(), baseAdjustedInAmount, flag == 1);
|
||||
_deposit(msg.sender, _dvm, IDODOV2(_dvm)._QUOTE_TOKEN_(), quoteAdjustedInAmount, flag == 2);
|
||||
|
||||
(shares, , ) = IDODOV2(_dvm).buyShares(msg.sender);
|
||||
// refund dust eth
|
||||
if (flag == 1 && msg.value > baseAdjustedInAmount) msg.sender.transfer(msg.value - baseAdjustedInAmount);
|
||||
if (flag == 2 && msg.value > quoteAdjustedInAmount) msg.sender.transfer(msg.value - quoteAdjustedInAmount);
|
||||
}
|
||||
|
||||
function _addDVMLiquidity(
|
||||
address dvmAddress,
|
||||
uint256 baseInAmount,
|
||||
uint256 quoteInAmount
|
||||
) internal view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
|
||||
(uint256 baseReserve, uint256 quoteReserve) = IDODOV2(dvmAddress).getVaultReserve();
|
||||
if (quoteReserve == 0 && baseReserve == 0) {
|
||||
baseAdjustedInAmount = baseInAmount;
|
||||
quoteAdjustedInAmount = quoteInAmount;
|
||||
}
|
||||
if (quoteReserve == 0 && baseReserve > 0) {
|
||||
baseAdjustedInAmount = baseInAmount;
|
||||
quoteAdjustedInAmount = 0;
|
||||
}
|
||||
if (quoteReserve > 0 && baseReserve > 0) {
|
||||
uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
|
||||
uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
|
||||
if (baseIncreaseRatio <= quoteIncreaseRatio) {
|
||||
baseAdjustedInAmount = baseInAmount;
|
||||
quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
|
||||
} else {
|
||||
quoteAdjustedInAmount = quoteInAmount;
|
||||
baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============ DPP Functions (create & reset) ============
|
||||
|
||||
function createDODOPrivatePool(
|
||||
address baseToken,
|
||||
address quoteToken,
|
||||
uint256 baseInAmount,
|
||||
uint256 quoteInAmount,
|
||||
uint256 lpFeeRate,
|
||||
uint256 i,
|
||||
uint256 k,
|
||||
bool isOpenTwap,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
preventReentrant
|
||||
judgeExpired(deadLine)
|
||||
returns (address newPrivatePool)
|
||||
{
|
||||
newPrivatePool = IDODOV2(_DPP_FACTORY_).createDODOPrivatePool();
|
||||
|
||||
address _baseToken = baseToken;
|
||||
address _quoteToken = quoteToken;
|
||||
_deposit(msg.sender, newPrivatePool, _baseToken, baseInAmount, _baseToken == _ETH_ADDRESS_);
|
||||
_deposit(
|
||||
msg.sender,
|
||||
newPrivatePool,
|
||||
_quoteToken,
|
||||
quoteInAmount,
|
||||
_quoteToken == _ETH_ADDRESS_
|
||||
);
|
||||
|
||||
if (_baseToken == _ETH_ADDRESS_) _baseToken = _WETH_;
|
||||
if (_quoteToken == _ETH_ADDRESS_) _quoteToken = _WETH_;
|
||||
|
||||
IDODOV2(_DPP_FACTORY_).initDODOPrivatePool(
|
||||
newPrivatePool,
|
||||
msg.sender,
|
||||
_baseToken,
|
||||
_quoteToken,
|
||||
lpFeeRate,
|
||||
k,
|
||||
i,
|
||||
isOpenTwap
|
||||
);
|
||||
}
|
||||
|
||||
function resetDODOPrivatePool(
|
||||
address dppAddress,
|
||||
uint256[] memory paramList, //0 - newLpFeeRate, 1 - newI, 2 - newK
|
||||
uint256[] memory amountList, //0 - baseInAmount, 1 - quoteInAmount, 2 - baseOutAmount, 3- quoteOutAmount
|
||||
uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
|
||||
uint256 minBaseReserve,
|
||||
uint256 minQuoteReserve,
|
||||
uint256 deadLine
|
||||
) external override payable preventReentrant judgeExpired(deadLine) {
|
||||
_deposit(
|
||||
msg.sender,
|
||||
dppAddress,
|
||||
IDODOV2(dppAddress)._BASE_TOKEN_(),
|
||||
amountList[0],
|
||||
flag == 1
|
||||
);
|
||||
_deposit(
|
||||
msg.sender,
|
||||
dppAddress,
|
||||
IDODOV2(dppAddress)._QUOTE_TOKEN_(),
|
||||
amountList[1],
|
||||
flag == 2
|
||||
);
|
||||
|
||||
require(IDODOV2(IDODOV2(dppAddress)._OWNER_()).reset(
|
||||
msg.sender,
|
||||
paramList[0],
|
||||
paramList[1],
|
||||
paramList[2],
|
||||
amountList[2],
|
||||
amountList[3],
|
||||
minBaseReserve,
|
||||
minQuoteReserve
|
||||
), "Reset Failed");
|
||||
|
||||
_withdraw(msg.sender, IDODOV2(dppAddress)._BASE_TOKEN_(), amountList[2], flag == 3);
|
||||
_withdraw(msg.sender, IDODOV2(dppAddress)._QUOTE_TOKEN_(), amountList[3], flag == 4);
|
||||
}
|
||||
|
||||
// ============ Swap ============
|
||||
|
||||
function dodoSwapV2ETHToToken(
|
||||
address toToken,
|
||||
uint256 minReturnAmount,
|
||||
address[] memory dodoPairs,
|
||||
uint256 directions,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
judgeExpired(deadLine)
|
||||
returns (uint256 returnAmount)
|
||||
{
|
||||
require(dodoPairs.length > 0, "DODOV2Proxy03Bsc: PAIRS_EMPTY");
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
uint256 originGas = gasleft();
|
||||
|
||||
uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
|
||||
IWETH(_WETH_).deposit{value: msg.value}();
|
||||
IWETH(_WETH_).transfer(dodoPairs[0], msg.value);
|
||||
|
||||
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
||||
if (i == dodoPairs.length - 1) {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(msg.sender);
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(msg.sender);
|
||||
}
|
||||
} else {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
|
||||
}
|
||||
}
|
||||
directions = directions >> 1;
|
||||
}
|
||||
|
||||
returnAmount = IERC20(toToken).balanceOf(msg.sender).sub(originToTokenBalance);
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
|
||||
_dodoGasReturn(originGas);
|
||||
|
||||
_execIncentive(isIncentive, _ETH_ADDRESS_, toToken, msg.value, returnAmount);
|
||||
|
||||
emit OrderHistory(
|
||||
_ETH_ADDRESS_,
|
||||
toToken,
|
||||
msg.sender,
|
||||
msg.value,
|
||||
returnAmount
|
||||
);
|
||||
}
|
||||
|
||||
function dodoSwapV2TokenToETH(
|
||||
address fromToken,
|
||||
uint256 fromTokenAmount,
|
||||
uint256 minReturnAmount,
|
||||
address[] memory dodoPairs,
|
||||
uint256 directions,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
judgeExpired(deadLine)
|
||||
returns (uint256 returnAmount)
|
||||
{
|
||||
require(dodoPairs.length > 0, "DODOV2Proxy03Bsc: PAIRS_EMPTY");
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
uint256 originGas = gasleft();
|
||||
|
||||
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
|
||||
|
||||
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
||||
if (i == dodoPairs.length - 1) {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(address(this));
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(address(this));
|
||||
}
|
||||
} else {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
|
||||
}
|
||||
}
|
||||
directions = directions >> 1;
|
||||
}
|
||||
returnAmount = IWETH(_WETH_).balanceOf(address(this));
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
IWETH(_WETH_).withdraw(returnAmount);
|
||||
msg.sender.transfer(returnAmount);
|
||||
|
||||
_dodoGasReturn(originGas);
|
||||
|
||||
_execIncentive(isIncentive, fromToken, _ETH_ADDRESS_, fromTokenAmount, returnAmount);
|
||||
|
||||
emit OrderHistory(
|
||||
fromToken,
|
||||
_ETH_ADDRESS_,
|
||||
msg.sender,
|
||||
fromTokenAmount,
|
||||
returnAmount
|
||||
);
|
||||
}
|
||||
|
||||
function dodoSwapV2TokenToToken(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
uint256 fromTokenAmount,
|
||||
uint256 minReturnAmount,
|
||||
address[] memory dodoPairs,
|
||||
uint256 directions,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
judgeExpired(deadLine)
|
||||
returns (uint256 returnAmount)
|
||||
{
|
||||
require(dodoPairs.length > 0, "DODOV2Proxy03Bsc: PAIRS_EMPTY");
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
uint256 originGas = gasleft();
|
||||
|
||||
uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
|
||||
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
|
||||
|
||||
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
||||
if (i == dodoPairs.length - 1) {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(msg.sender);
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(msg.sender);
|
||||
}
|
||||
} else {
|
||||
if (directions& 1 == 0) {
|
||||
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
||||
} else {
|
||||
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
|
||||
}
|
||||
}
|
||||
directions = directions >> 1;
|
||||
}
|
||||
returnAmount = IERC20(toToken).balanceOf(msg.sender).sub(originToTokenBalance);
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
|
||||
_dodoGasReturn(originGas);
|
||||
|
||||
_execIncentive(isIncentive, fromToken, toToken, fromTokenAmount, returnAmount);
|
||||
|
||||
emit OrderHistory(
|
||||
fromToken,
|
||||
toToken,
|
||||
msg.sender,
|
||||
fromTokenAmount,
|
||||
returnAmount
|
||||
);
|
||||
}
|
||||
|
||||
function externalSwap(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
address approveTarget,
|
||||
address swapTarget,
|
||||
uint256 fromTokenAmount,
|
||||
uint256 minReturnAmount,
|
||||
bytes memory callDataConcat,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
judgeExpired(deadLine)
|
||||
returns (uint256 returnAmount)
|
||||
{
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
require(fromToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_SELL_CHI");
|
||||
require(toToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_BUY_CHI");
|
||||
|
||||
uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender);
|
||||
if (fromToken != _ETH_ADDRESS_) {
|
||||
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(
|
||||
fromToken,
|
||||
msg.sender,
|
||||
address(this),
|
||||
fromTokenAmount
|
||||
);
|
||||
IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount);
|
||||
}
|
||||
|
||||
require(isWhiteListed[swapTarget], "DODOV2Proxy03Bsc: Not Whitelist Contract");
|
||||
(bool success, ) = swapTarget.call{value: fromToken == _ETH_ADDRESS_ ? msg.value : 0}(callDataConcat);
|
||||
|
||||
require(success, "DODOV2Proxy03Bsc: External Swap execution Failed");
|
||||
|
||||
IERC20(toToken).universalTransfer(
|
||||
msg.sender,
|
||||
IERC20(toToken).universalBalanceOf(address(this))
|
||||
);
|
||||
|
||||
returnAmount = IERC20(toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance);
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
|
||||
_externalGasReturn();
|
||||
|
||||
_execIncentive(isIncentive, fromToken, toToken, fromTokenAmount, returnAmount);
|
||||
|
||||
emit OrderHistory(
|
||||
fromToken,
|
||||
toToken,
|
||||
msg.sender,
|
||||
fromTokenAmount,
|
||||
returnAmount
|
||||
);
|
||||
}
|
||||
|
||||
function dodoSwapV1(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
uint256 fromTokenAmount,
|
||||
uint256 minReturnAmount,
|
||||
address[] memory dodoPairs,
|
||||
uint256 directions,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
)
|
||||
external
|
||||
override
|
||||
payable
|
||||
judgeExpired(deadLine)
|
||||
returns (uint256 returnAmount)
|
||||
{
|
||||
require(dodoPairs.length > 0, "DODOV2Proxy03Bsc: PAIRS_EMPTY");
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
require(fromToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_SELL_CHI");
|
||||
require(toToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_BUY_CHI");
|
||||
|
||||
uint256 originGas = gasleft();
|
||||
|
||||
address _fromToken = fromToken;
|
||||
address _toToken = toToken;
|
||||
|
||||
_deposit(msg.sender, address(this), _fromToken, fromTokenAmount, _fromToken == _ETH_ADDRESS_);
|
||||
|
||||
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
||||
address curDodoPair = dodoPairs[i];
|
||||
if (directions & 1 == 0) {
|
||||
address curDodoBase = IDODOV1(curDodoPair)._BASE_TOKEN_();
|
||||
require(curDodoBase != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_CHI");
|
||||
uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this));
|
||||
IERC20(curDodoBase).universalApproveMax(curDodoPair, curAmountIn);
|
||||
IDODOV1(curDodoPair).sellBaseToken(curAmountIn, 0, "");
|
||||
} else {
|
||||
address curDodoQuote = IDODOV1(curDodoPair)._QUOTE_TOKEN_();
|
||||
require(curDodoQuote != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_CHI");
|
||||
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
|
||||
IERC20(curDodoQuote).universalApproveMax(curDodoPair, curAmountIn);
|
||||
uint256 canBuyBaseAmount = IDODOSellHelper(_DODO_SELL_HELPER_).querySellQuoteToken(
|
||||
curDodoPair,
|
||||
curAmountIn
|
||||
);
|
||||
IDODOV1(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
|
||||
}
|
||||
directions = directions >> 1;
|
||||
}
|
||||
|
||||
|
||||
if (_toToken == _ETH_ADDRESS_) {
|
||||
returnAmount = IWETH(_WETH_).balanceOf(address(this));
|
||||
IWETH(_WETH_).withdraw(returnAmount);
|
||||
} else {
|
||||
returnAmount = IERC20(_toToken).tokenBalanceOf(address(this));
|
||||
}
|
||||
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
IERC20(_toToken).universalTransfer(msg.sender, returnAmount);
|
||||
|
||||
_dodoGasReturn(originGas);
|
||||
|
||||
_execIncentive(isIncentive, _fromToken, _toToken, fromTokenAmount, returnAmount);
|
||||
|
||||
emit OrderHistory(_fromToken, _toToken, msg.sender, fromTokenAmount, returnAmount);
|
||||
}
|
||||
|
||||
|
||||
function mixSwap(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
uint256 fromTokenAmount,
|
||||
uint256 minReturnAmount,
|
||||
address[] memory mixAdapters,
|
||||
address[] memory mixPairs,
|
||||
address[] memory assetTo,
|
||||
uint256 directions,
|
||||
bool isIncentive,
|
||||
uint256 deadLine
|
||||
) external override payable judgeExpired(deadLine) returns (uint256 returnAmount) {
|
||||
require(mixPairs.length > 0, "DODOV2Proxy03Bsc: PAIRS_EMPTY");
|
||||
require(mixPairs.length == mixAdapters.length, "DODOV2Proxy03Bsc: PAIR_ADAPTER_NOT_MATCH");
|
||||
require(mixPairs.length == assetTo.length - 1, "DODOV2Proxy03Bsc: PAIR_ASSETTO_NOT_MATCH");
|
||||
require(minReturnAmount > 0, "DODOV2Proxy03Bsc: RETURN_AMOUNT_ZERO");
|
||||
|
||||
address _fromToken = fromToken;
|
||||
address _toToken = toToken;
|
||||
uint256 _fromTokenAmount = fromTokenAmount;
|
||||
|
||||
require(_fromToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_SELL_CHI");
|
||||
require(_toToken != _CHI_TOKEN_, "DODOV2Proxy03Bsc: NOT_SUPPORT_BUY_CHI");
|
||||
|
||||
uint256 originGas = gasleft();
|
||||
uint256 toTokenOriginBalance = IERC20(_toToken).universalBalanceOf(msg.sender);
|
||||
|
||||
_deposit(msg.sender, assetTo[0], _fromToken, _fromTokenAmount, _fromToken == _ETH_ADDRESS_);
|
||||
|
||||
for (uint256 i = 0; i < mixPairs.length; i++) {
|
||||
if (directions & 1 == 0) {
|
||||
IDODOAdapter(mixAdapters[i]).sellBase(assetTo[i + 1],mixPairs[i]);
|
||||
} else {
|
||||
IDODOAdapter(mixAdapters[i]).sellQuote(assetTo[i + 1],mixPairs[i]);
|
||||
}
|
||||
directions = directions >> 1;
|
||||
}
|
||||
|
||||
if(_toToken == _ETH_ADDRESS_) {
|
||||
returnAmount = IWETH(_WETH_).balanceOf(address(this));
|
||||
IWETH(_WETH_).withdraw(returnAmount);
|
||||
msg.sender.transfer(returnAmount);
|
||||
}else {
|
||||
returnAmount = IERC20(_toToken).tokenBalanceOf(msg.sender).sub(toTokenOriginBalance);
|
||||
}
|
||||
|
||||
require(returnAmount >= minReturnAmount, "DODOV2Proxy03Bsc: Return amount is not enough");
|
||||
|
||||
_dodoGasReturn(originGas);
|
||||
|
||||
_execIncentive(isIncentive, _fromToken, _toToken, _fromTokenAmount, returnAmount);
|
||||
|
||||
emit OrderHistory(
|
||||
_fromToken,
|
||||
_toToken,
|
||||
msg.sender,
|
||||
_fromTokenAmount,
|
||||
returnAmount
|
||||
);
|
||||
}
|
||||
|
||||
//============ CrowdPooling Functions (create & bid) ============
|
||||
|
||||
function createCrowdPooling(
|
||||
address baseToken,
|
||||
address quoteToken,
|
||||
uint256 baseInAmount,
|
||||
uint256[] memory timeLine,
|
||||
uint256[] memory valueList,
|
||||
bool isOpenTWAP,
|
||||
uint256 deadLine
|
||||
) external override payable preventReentrant judgeExpired(deadLine) returns (address payable newCrowdPooling) {
|
||||
address _baseToken = baseToken;
|
||||
address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken;
|
||||
|
||||
newCrowdPooling = IDODOV2(_CP_FACTORY_).createCrowdPooling();
|
||||
|
||||
_deposit(
|
||||
msg.sender,
|
||||
newCrowdPooling,
|
||||
_baseToken,
|
||||
baseInAmount,
|
||||
false
|
||||
);
|
||||
|
||||
newCrowdPooling.transfer(msg.value);
|
||||
|
||||
IDODOV2(_CP_FACTORY_).initCrowdPooling(
|
||||
newCrowdPooling,
|
||||
msg.sender,
|
||||
_baseToken,
|
||||
_quoteToken,
|
||||
timeLine,
|
||||
valueList,
|
||||
isOpenTWAP
|
||||
);
|
||||
}
|
||||
|
||||
function bid(
|
||||
address cpAddress,
|
||||
uint256 quoteAmount,
|
||||
uint8 flag, // 0 - ERC20, 1 - quoteInETH
|
||||
uint256 deadLine
|
||||
) external override payable preventReentrant judgeExpired(deadLine) {
|
||||
_deposit(msg.sender, cpAddress, IDODOV2(cpAddress)._QUOTE_TOKEN_(), quoteAmount, flag == 1);
|
||||
IDODOV2(cpAddress).bid(msg.sender);
|
||||
}
|
||||
|
||||
|
||||
function addLiquidityToV1(
|
||||
address pair,
|
||||
uint256 baseAmount,
|
||||
uint256 quoteAmount,
|
||||
uint256 baseMinShares,
|
||||
uint256 quoteMinShares,
|
||||
uint8 flag, // 0 erc20 In 1 baseInETH 2 quoteIn ETH
|
||||
uint256 deadLine
|
||||
) external override payable preventReentrant judgeExpired(deadLine) returns(uint256 baseShares, uint256 quoteShares) {
|
||||
address _baseToken = IDODOV1(pair)._BASE_TOKEN_();
|
||||
address _quoteToken = IDODOV1(pair)._QUOTE_TOKEN_();
|
||||
|
||||
_deposit(msg.sender, address(this), _baseToken, baseAmount, flag == 1);
|
||||
_deposit(msg.sender, address(this), _quoteToken, quoteAmount, flag == 2);
|
||||
|
||||
|
||||
if(baseAmount > 0) {
|
||||
IERC20(_baseToken).universalApproveMax(pair, baseAmount);
|
||||
baseShares = IDODOV1(pair).depositBaseTo(msg.sender, baseAmount);
|
||||
}
|
||||
if(quoteAmount > 0) {
|
||||
IERC20(_quoteToken).universalApproveMax(pair, quoteAmount);
|
||||
quoteShares = IDODOV1(pair).depositQuoteTo(msg.sender, quoteAmount);
|
||||
}
|
||||
|
||||
require(baseShares >= baseMinShares && quoteShares >= quoteMinShares,"DODOV2Proxy03Bsc: Return DLP is not enough");
|
||||
}
|
||||
|
||||
|
||||
function _deposit(
|
||||
address from,
|
||||
address to,
|
||||
address token,
|
||||
uint256 amount,
|
||||
bool isETH
|
||||
) internal {
|
||||
if (isETH) {
|
||||
if (amount > 0) {
|
||||
IWETH(_WETH_).deposit{value: amount}();
|
||||
if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
|
||||
}
|
||||
} else {
|
||||
IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(token, from, to, amount);
|
||||
}
|
||||
}
|
||||
|
||||
function _withdraw(
|
||||
address payable to,
|
||||
address token,
|
||||
uint256 amount,
|
||||
bool isETH
|
||||
) internal {
|
||||
if (isETH) {
|
||||
if (amount > 0) {
|
||||
IWETH(_WETH_).withdraw(amount);
|
||||
to.transfer(amount);
|
||||
}
|
||||
} else {
|
||||
if (amount > 0) {
|
||||
SafeERC20.safeTransfer(IERC20(token), to, amount);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function _dodoGasReturn(uint256 originGas) internal {
|
||||
uint256 _gasDodoMaxReturn = _GAS_DODO_MAX_RETURN_;
|
||||
if(_gasDodoMaxReturn > 0) {
|
||||
uint256 calcGasTokenBurn = originGas.sub(gasleft()) / 65000;
|
||||
uint256 gasTokenBurn = calcGasTokenBurn > _gasDodoMaxReturn ? _gasDodoMaxReturn : calcGasTokenBurn;
|
||||
if(gasTokenBurn >= 3 && gasleft() > 27710 + gasTokenBurn * 6080)
|
||||
IChi(_CHI_TOKEN_).freeUpTo(gasTokenBurn);
|
||||
}
|
||||
}
|
||||
|
||||
function _externalGasReturn() internal {
|
||||
uint256 _gasExternalReturn = _GAS_EXTERNAL_RETURN_;
|
||||
if(_gasExternalReturn > 0) {
|
||||
if(gasleft() > 27710 + _gasExternalReturn * 6080)
|
||||
IChi(_CHI_TOKEN_).freeUpTo(_gasExternalReturn);
|
||||
}
|
||||
}
|
||||
|
||||
function _execIncentive(bool isIncentive, address fromToken, address toToken, uint256 fromAmount, uint256 returnAmount) internal {
|
||||
//TODO: gas 测算
|
||||
if(isIncentive) {
|
||||
IDODOIncentiveBsc(_DODO_INCENTIVE_).triggerIncentive(fromToken, toToken, fromAmount, returnAmount, msg.sender);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
19
contracts/intf/IDODOIncentiveBsc.sol
Normal file
19
contracts/intf/IDODOIncentiveBsc.sol
Normal file
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
|
||||
Copyright 2020 DODO ZOO.
|
||||
SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
*/
|
||||
|
||||
pragma solidity 0.6.9;
|
||||
pragma experimental ABIEncoderV2;
|
||||
|
||||
interface IDODOIncentiveBsc {
|
||||
function triggerIncentive(
|
||||
address fromToken,
|
||||
address toToken,
|
||||
uint256 fromAmount,
|
||||
uint256 returnAmount,
|
||||
address assetTo
|
||||
) external;
|
||||
}
|
||||
13
contracts/intf/ILockedTokenVault02.sol
Normal file
13
contracts/intf/ILockedTokenVault02.sol
Normal file
@@ -0,0 +1,13 @@
|
||||
/*
|
||||
|
||||
Copyright 2020 DODO ZOO.
|
||||
SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
*/
|
||||
|
||||
pragma solidity 0.6.9;
|
||||
pragma experimental ABIEncoderV2;
|
||||
|
||||
interface ILockedTokenVault02 {
|
||||
function tradeIncentive(address trader, uint256 amount) external;
|
||||
}
|
||||
Reference in New Issue
Block a user