KyberSwap

1pragma solidity 0.6.6;
2
3import "./utils/WithdrawableNoModifiers.sol";
4import "./utils/Utils5.sol";
5import "./utils/zeppelin/ReentrancyGuard.sol";
6import "./utils/zeppelin/SafeERC20.sol";
7import "./IKyberNetwork.sol";
8import "./IKyberReserve.sol";
9import "./IKyberFeeHandler.sol";
10import "./IKyberDao.sol";
11import "./IKyberMatchingEngine.sol";
12import "./IKyberStorage.sol";
13import "./IGasHelper.sol";
14
15
16/**
17 *   @title kyberNetwork main contract
18 *   Interacts with contracts:
19 *       kyberDao: to retrieve fee data
20 *       kyberFeeHandler: accumulates and distributes trade fees
21 *       kyberMatchingEngine: parse user hint and run reserve matching algorithm
22 *       kyberStorage: store / access reserves, token listings and contract addresses
23 *       kyberReserve(s): query rate and trade
24 */
25contract KyberNetwork is WithdrawableNoModifiers, Utils5, IKyberNetwork, ReentrancyGuard {
26    using SafeERC20 for IERC20;
27
28    struct NetworkFeeData {
29        uint64 expiryTimestamp;
30        uint16 feeBps;
31    }
32
33    /// @notice Stores work data for reserves (either for token -> eth, or eth -> token)
34    /// @dev Variables are in-place, ie. reserve with addresses[i] has id of ids[i], offers rate of rates[i], etc.
35    /// @param addresses List of reserve addresses selected for the trade
36    /// @param ids List of reserve ids, to be used for KyberTrade event
37    /// @param rates List of rates that were offered by the reserves
38    /// @param isFeeAccountedFlags List of reserves requiring users to pay network fee
39    /// @param isEntitledRebateFlags List of reserves eligible for rebates
40    /// @param splitsBps List of proportions of trade amount allocated to the reserves.
41    ///     If there is only 1 reserve, then it should have a value of 10000 bps
42    /// @param srcAmounts Source amount per reserve.
43    /// @param decimals Token decimals. Src decimals when for src -> eth, dest decimals when eth -> dest
44    struct ReservesData {
45        IKyberReserve[] addresses;
46        bytes32[] ids;
47        uint256[] rates;
48        bool[] isFeeAccountedFlags;
49        bool[] isEntitledRebateFlags;
50        uint256[] splitsBps;
51        uint256[] srcAmounts;
52        uint256 decimals;
53    }
54
55    /// @notice Main trade data structure, is initialised and used for the entire trade flow
56    /// @param input Initialised when initTradeInput is called. Stores basic trade info
57    /// @param tokenToEth Stores information about reserves that were selected for src -> eth side of trade
58    /// @param ethToToken Stores information about reserves that were selected for eth -> dest side of trade
59    /// @param tradeWei Trade amount in ether wei, before deducting fees.
60    /// @param networkFeeWei Network fee in ether wei. For t2t trades, it can go up to 200% of networkFeeBps
61    /// @param platformFeeWei Platform fee in ether wei
62    /// @param networkFeeBps Network fee bps determined by kyberDao, or default value
63    /// @param numEntitledRebateReserves No. of reserves that are eligible for rebates
64    /// @param feeAccountedBps Proportion of this trade that fee is accounted to, in BPS. Up to 2 * BPS
65    struct TradeData {
66        TradeInput input;
67        ReservesData tokenToEth;
68        ReservesData ethToToken;
69        uint256 tradeWei;
70        uint256 networkFeeWei;
71        uint256 platformFeeWei;
72        uint256 networkFeeBps;
73        uint256 numEntitledRebateReserves;
74        uint256 feeAccountedBps; // what part of this trade is fee paying. for token -> token - up to 200%
75    }
76
77    struct TradeInput {
78        address payable trader;
79        IERC20 src;
80        uint256 srcAmount;
81        IERC20 dest;
82        address payable destAddress;
83        uint256 maxDestAmount;
84        uint256 minConversionRate;
85        address platformWallet;
86        uint256 platformFeeBps;
87    }
88
89    uint256 internal constant PERM_HINT_GET_RATE = 1 << 255; // for backwards compatibility
90    uint256 internal constant DEFAULT_NETWORK_FEE_BPS = 25; // till we read value from kyberDao
91    uint256 internal constant MAX_APPROVED_PROXIES = 2; // limit number of proxies that can trade here
92
93    IKyberFeeHandler internal kyberFeeHandler;
94    IKyberDao internal kyberDao;
95    IKyberMatchingEngine internal kyberMatchingEngine;
96    IKyberStorage internal kyberStorage;
97    IGasHelper internal gasHelper;
98
99    NetworkFeeData internal networkFeeData; // data is feeBps and expiry timestamp
100    uint256 internal maxGasPriceValue = 50 * 1000 * 1000 * 1000; // 50 gwei
101    bool internal isEnabled = false; // is network enabled
102
103    mapping(address => bool) internal kyberProxyContracts;
104
105    event EtherReceival(address indexed sender, uint256 amount);
106    event KyberFeeHandlerUpdated(IKyberFeeHandler newKyberFeeHandler);
107    event KyberMatchingEngineUpdated(IKyberMatchingEngine newKyberMatchingEngine);
108    event GasHelperUpdated(IGasHelper newGasHelper);
109    event KyberDaoUpdated(IKyberDao newKyberDao);
110    event KyberNetworkParamsSet(uint256 maxGasPrice, uint256 negligibleRateDiffBps);
111    event KyberNetworkSetEnable(bool isEnabled);
112    event KyberProxyAdded(address kyberProxy);
113    event KyberProxyRemoved(address kyberProxy);
114
115    event ListedReservesForToken(
116        IERC20 indexed token,
117        address[] reserves,
118        bool add
119    );
120
121    constructor(address _admin, IKyberStorage _kyberStorage)
122        public
123        WithdrawableNoModifiers(_admin)
124    {
125        updateNetworkFee(now, DEFAULT_NETWORK_FEE_BPS);
126        kyberStorage = _kyberStorage;
127    }
128
129    receive() external payable {
130        emit EtherReceival(msg.sender, msg.value);
131    }
132
133    /// @notice Backward compatible function
134    /// @notice Use token address ETH_TOKEN_ADDRESS for ether
135    /// @dev Trade from src to dest token and sends dest token to destAddress
136    /// @param trader Address of the taker side of this trade
137    /// @param src Source token
138    /// @param srcAmount Amount of src tokens in twei
139    /// @param dest Destination token
140    /// @param destAddress Address to send tokens to
141    /// @param maxDestAmount A limit on the amount of dest tokens in twei
142    /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade reverts
143    /// @param walletId Platform wallet address for receiving fees
144    /// @param hint Advanced instructions for running the trade 
145    /// @return destAmount Amount of actual dest tokens in twei
146    function tradeWithHint(
147        address payable trader,
148        ERC20 src,
149        uint256 srcAmount,
150        ERC20 dest,
151        address payable destAddress,
152        uint256 maxDestAmount,
153        uint256 minConversionRate,
154        address payable walletId,

JavaScript Tests