amountIn

amountOutMin

path

deadline

swapExactTokensForTokens

amounts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "./interfaces/IERC20.sol";

contract MultiHop {
    /**
     *  PERFORM A MULTI-HOP SWAP WITH ROUTER EXERCISE
     *
     *  The contract has an initial balance of 10 MKR.
     *  The challenge is to swap the contract entire MKR balance for ELON token, using WETH as the middleware token.
     *
     */
    address public immutable router;

    constructor(address _router) {
        router = _router;
    }

    function performMultiHopWithRouter(address mkr, address weth, address elon, uint256 deadline) public {
        // your code start here
        address[] memory path = new address[](3);
        (path[0], path[1], path[2]) = (mkr, weth, elon);

        IERC20(mkr).approve(router, 10 ether);
        IUniswapV2Router(router).swapExactTokensForTokens(10 ether, 0, path, address(this), deadline);
    }
}

interface IUniswapV2Router {
    /**
     *     amountIn: the amount of input tokens to swap.
     *     amountOutMin: the minimum amount of output tokens that must be received for the transaction not to revert.
     *     path: an array of token addresses.
     *     to: recipient address to receive the liquidity tokens.
     *     deadline: timestamp after which the transaction will revert.
     */
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
}


owner

spender

allowance

value

approve

balanceOf

decimals

name

symbol

totalSupply

transfer

from

transferFrom

Approval

Transfer

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address owner) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external;
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}


The `MultiHop` contract facilitates a multi-hop token swap using a Uniswap V2 router. It starts with an initial balance of 10 MKR tokens and swaps the entire MKR balance for ELON tokens, using WETH as an intermediary. The `performMultiHopWithRouter` function sets up the swap path (MKR -> WETH -> ELON), approves the router to spend MKR, and executes the swap before a specified deadline.