1  pragma solidity >=0.6.0;
  2  
  3  import "../../../contracts/deployment/ManagedContract.sol";
  4  import "../../../contracts/governance/ProtocolSettings.sol";
  5  import "../../../contracts/interfaces/IUniswapV2Router01.sol";
  6  import "../../../contracts/interfaces/UnderlyingFeed.sol";
  7  import "../../../contracts/utils/ERC20.sol";
  8  import "../../../contracts/utils/SafeMath.sol";
  9  import "../../common/mock/ERC20Mock.t.sol";
 10  
 11  contract UniswapV2RouterMock is ManagedContract, IUniswapV2Router01 {
 12  
 13      using SafeMath for uint;
 14  
 15      ProtocolSettings private settings;
 16      UnderlyingFeed private feed;
 17      ERC20 private underlying;
 18      ERC20Mock private stablecoin;
 19  
 20      function initialize(Deployer deployer) override internal {
 21  
 22          settings = ProtocolSettings(deployer.getContractAddress("ProtocolSettings"));
 23          feed = UnderlyingFeed(deployer.getContractAddress("UnderlyingFeed"));
 24          underlying = ERC20(feed.getUnderlyingAddr());
 25          stablecoin = ERC20Mock(deployer.getContractAddress("StablecoinA"));
 26      }
 27  
 28      function factory() override external pure returns (address) {
 29  
 30          return address(0);
 31      }
 32  
 33      function WETH() override external pure returns (address){
 34  
 35          revert("not implemented");
 36      }
 37  
 38      function addLiquidity(
 39          address,
 40          address,
 41          uint,
 42          uint,
 43          uint,
 44          uint,
 45          address,
 46          uint
 47      )
 48          override
 49          external
 50          returns (uint, uint, uint)
 51      {
 52          revert("not implemented");
 53      }
 54  
 55      function addLiquidityETH(
 56          address,
 57          uint,
 58          uint,
 59          uint,
 60          address,
 61          uint
 62      )
 63          override
 64          external
 65          payable
 66          returns (uint, uint, uint)
 67      {
 68          revert("not implemented");
 69      }
 70  
 71      function removeLiquidity(
 72          address,
 73          address,
 74          uint,
 75          uint,
 76          uint,
 77          address,
 78          uint
 79      )
 80          override
 81          external
 82          returns (uint, uint)
 83      {
 84          revert("not implemented");
 85      }
 86  
 87      function removeLiquidityETH(
 88          address,
 89          uint,
 90          uint,
 91          uint,
 92          address,
 93          uint
 94      )
 95          override
 96          external
 97          returns (uint, uint)
 98      {
 99          revert("not implemented");
100      }
101  
102      function removeLiquidityWithPermit(
103          address,
104          address,
105          uint,
106          uint,
107          uint,
108          address,
109          uint,
110          bool, uint8, bytes32, bytes32
111      )
112          override
113          external
114          returns (uint, uint)
115      {
116          revert("not implemented");
117      }
118  
119      function removeLiquidityETHWithPermit(
120          address,
121          uint,
122          uint,
123          uint,
124          address,
125          uint,
126          bool, uint8, bytes32, bytes32
127      )
128          override
129          external
130          returns (uint, uint)
131      {
132          revert("not implemented");
133      }
134  
135      function swapExactTokensForTokens(
136          uint,
137          uint,
138          address[] calldata,
139          address,
140          uint
141      )
142          override
143          external
144          returns (uint[] memory)
145      {
146          revert("not implemented");
147      }
148  
149      function swapTokensForExactTokens(
150          uint amountOut,
151          uint amountInMax,
152          address[] calldata path,
153          address to,
154          uint
155      )
156          override
157          external
158          returns (uint[] memory amounts)
159      {
160          require(
161              path[0] == address(underlying) && path[1] == address(stablecoin),
162              "invalid path"
163          );
164  
165          (uint r, uint b) = settings.getTokenRate(path[1]);
166          (, int p) = feed.getLatestPrice();
167          uint v = amountOut.mul(10 ** uint(underlying.decimals())).div(uint(p).mul(r).div(b));
168  
169          require(v <= amountInMax, "amountInMax exceeded");
170          underlying.transferFrom(msg.sender, address(this), v);
171          stablecoin.issue(to, amountOut);
172  
173          amounts = new uint[](2);
174          amounts[0] = v;
175          amounts[1] = amountOut;
176      }
177  
178      function swapExactETHForTokens(
179          uint,
180          address[] calldata,
181          address,
182          uint
183      )
184          override
185          external
186          payable
187          returns (uint[] memory)
188      {
189          revert("not implemented");
190      }
191  
192      function swapTokensForExactETH(
193          uint,
194          uint,
195          address[] calldata,
196          address,
197          uint
198      )
199          override
200          external
201          returns (uint[] memory)
202      {
203          revert("not implemented");
204      }
205  
206      function swapExactTokensForETH(
207          uint,
208          uint,
209          address[] calldata,
210          address,
211          uint
212      )
213          override
214          external
215          returns (uint[] memory)
216      {
217          revert("not implemented");
218      }
219  
220      function swapETHForExactTokens(
221          uint,
222          address[] calldata,
223          address,
224          uint
225      )
226          override
227          external
228          payable
229          returns (uint[] memory)
230      {
231          revert("not implemented");
232      }
233  
234      function quote(
235          uint,
236          uint,
237          uint
238      )
239          override
240          external
241          pure
242          returns (uint)
243      {
244          revert("not implemented");
245      }
246  
247      function getAmountOut(
248          uint,
249          uint,
250          uint
251      )
252          override
253          external
254          pure
255          returns (uint)
256      {
257          revert("not implemented");
258      }
259  
260      function getAmountIn(
261          uint,
262          uint,
263          uint
264      )
265          override
266          external
267          pure
268          returns (uint)
269      {
270          revert("not implemented");
271      }
272  
273      function getAmountsOut(
274          uint,
275          address[] calldata
276      )
277          override
278          external
279          view
280          returns (uint[] memory)
281      {
282          revert("not implemented");
283      }
284  
285      function getAmountsIn(
286          uint,
287          address[] calldata
288      )
289          override
290          external
291          view
292          returns (uint[] memory)
293      {
294          revert("not implemented");
295      }
296  }