1inch

1// SPDX-License-Identifier: MIT
2
3pragma solidity ^0.6.12;
4pragma experimental ABIEncoderV2;
5
6import "@openzeppelin/contracts/access/Ownable.sol";
7import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
8import "@openzeppelin/contracts/utils/Pausable.sol";
9import "./interfaces/IChi.sol";
10import "./interfaces/IERC20Permit.sol";
11import "./interfaces/IOneInchCaller.sol";
12import "./helpers/RevertReasonParser.sol";
13import "./helpers/UniERC20.sol";
14
15
16contract OneInchExchange is Ownable, Pausable {
17    using SafeMath for uint256;
18    using SafeERC20 for IERC20;
19    using UniERC20 for IERC20;
20
21    uint256 private constant _PARTIAL_FILL = 0x01;
22    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
23    uint256 private constant _SHOULD_CLAIM = 0x04;
24    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
25    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
26
27    struct SwapDescription {
28        IERC20 srcToken;
29        IERC20 dstToken;
30        address srcReceiver;
31        address dstReceiver;
32        uint256 amount;
33        uint256 minReturnAmount;
34        uint256 guaranteedAmount;
35        uint256 flags;
36        address referrer;
37        bytes permit;
38    }
39
40    event Swapped(
41        address indexed sender,
42        IERC20 indexed srcToken,
43        IERC20 indexed dstToken,
44        address dstReceiver,
45        uint256 amount,
46        uint256 spentAmount,
47        uint256 returnAmount,
48        uint256 minReturnAmount,
49        uint256 guaranteedAmount,
50        address referrer
51    );
52
53    event Error(
54        string reason
55    );
56
57    function discountedSwap(
58        IOneInchCaller caller,
59        SwapDescription calldata desc,
60        IOneInchCaller.CallDescription[] calldata calls
61    )
62        external
63        payable
64        returns (uint256 returnAmount)
65    {
66        uint256 initialGas = gasleft();
67
68        address chiSource = address(0);
69        if (desc.flags & _BURN_FROM_MSG_SENDER != 0) {
70            chiSource = msg.sender;
71        } else if (desc.flags & _BURN_FROM_TX_ORIGIN != 0) {
72            chiSource = tx.origin; // solhint-disable-line avoid-tx-origin
73        } else {
74            revert("Incorrect CHI burn flags");
75        }
76
77        // solhint-disable-next-line avoid-low-level-calls
78        (bool success, bytes memory data) = address(this).delegatecall(abi.encodeWithSelector(this.swap.selector, caller, desc, calls));
79        if (success) {
80            returnAmount = abi.decode(data, (uint256));
81        } else {
82            if (msg.value > 0) {
83                msg.sender.transfer(msg.value);
84            }
85            emit Error(RevertReasonParser.parse(data, "Swap failed: "));
86        }
87
88        (IChi chi, uint256 amount) = caller.calculateGas(initialGas.sub(gasleft()), desc.flags, msg.data.length);
89        chi.freeFromUpTo(chiSource, amount);
90    }
91
92    function swap(
93        IOneInchCaller caller,
94        SwapDescription calldata desc,
95        IOneInchCaller.CallDescription[] calldata calls
96    )
97        external
98        payable
99        whenNotPaused
100        returns (uint256 returnAmount)
101    {
102        require(desc.minReturnAmount > 0, "Min return should not be 0");
103        require(calls.length > 0, "Call data should exist");
104
105        uint256 flags = desc.flags;
106        IERC20 srcToken = desc.srcToken;
107        IERC20 dstToken = desc.dstToken;
108
109        if (flags & _REQUIRES_EXTRA_ETH != 0) {
110            require(msg.value > (srcToken.isETH() ? desc.amount : 0), "Invalid msg.value");
111        } else {
112            require(msg.value == (srcToken.isETH() ? desc.amount : 0), "Invalid msg.value");
113        }
114
115        if (flags & _SHOULD_CLAIM != 0) {
116            require(!srcToken.isETH(), "Claim token is ETH");
117            _claim(srcToken, desc.srcReceiver, desc.amount, desc.permit);
118        }
119
120        address dstReceiver = (desc.dstReceiver == address(0)) ? msg.sender : desc.dstReceiver;
121        uint256 initialSrcBalance = (flags & _PARTIAL_FILL != 0) ? srcToken.uniBalanceOf(msg.sender) : 0;
122        uint256 initialDstBalance = dstToken.uniBalanceOf(dstReceiver);
123
124        caller.makeCalls{value: msg.value}(calls);
125
126        uint256 spentAmount = desc.amount;
127        returnAmount = dstToken.uniBalanceOf(dstReceiver).sub(initialDstBalance);
128
129        if (flags & _PARTIAL_FILL != 0) {
130            spentAmount = initialSrcBalance.add(desc.amount).sub(srcToken.uniBalanceOf(msg.sender));
131            require(returnAmount.mul(desc.amount) >= desc.minReturnAmount.mul(spentAmount), "Return amount is not enough");
132        } else {
133            require(returnAmount >= desc.minReturnAmount, "Return amount is not enough");
134        }
135
136        _emitSwapped(desc, srcToken, dstToken, dstReceiver, spentAmount, returnAmount);
137    }
138
139    function _emitSwapped(
140        SwapDescription calldata desc,
141        IERC20 srcToken,
142        IERC20 dstToken,
143        address dstReceiver,
144        uint256 spentAmount,
145        uint256 returnAmount
146     ) private {
147        emit Swapped(
148            msg.sender,
149            srcToken,
150            dstToken,
151            dstReceiver,
152            desc.amount,
153            spentAmount,
154            returnAmount,
155            desc.minReturnAmount,
156            desc.guaranteedAmount,
157            desc.referrer
158        );
159    }
160
161    function _claim(IERC20 token, address dst, uint256 amount, bytes calldata permit) private {
162        // TODO: Is it safe to call permit on tokens without implemented permit? Fallback will be called. Is it bad for proxies?
163
164        if (permit.length == 32 * 7) {
165            // solhint-disable-next-line avoid-low-level-calls
166            (bool success, bytes memory result) = address(token).call(abi.encodeWithSelector(IERC20Permit.permit.selector, permit));
167            if (!success) {
168                revert(RevertReasonParser.parse(result, "Permit call failed: "));
169            }
170        }
171
172        token.safeTransferFrom(msg.sender, dst, amount);
173    }
174
175    function rescueFunds(IERC20 token, uint256 amount) external onlyOwner {
176        token.uniTransfer(msg.sender, amount);
177    }
178
179    function pause() external onlyOwner {
180        _pause();
181    }

JavaScript Tests