How do I do the exercises (UNISWAPV2) ??

[theblack2ke]

Hello
I started recently the uniswap V2 course
Everything going great until now
But I have a little problem.
I wanted to do the exercises my self.
So I wanted to ask how do I implement the uniswap in my system to try to do the test ?
Should I just download them in my /lib folder and try to change each import when working.
Or is there another way ??

I know my question is a little bit novice for someone taking the course.

[EngrPips]

Do you mean you want to run the process locally instead of running a fork test?

[theblack2ke]

When I mean test I mean the "test exercises"
And no I don't mean for test
I was just asking is once i download the uniswap codebase how should I do with the imports since I don't have the same as the one in the course

from the course :

at my side (After I downloaded it in my lib folder) :
If u see the at my side some contracts are not in "src"

[theblack2ke]

What I am asking is should I change the import at my side too Or their is an appropriate codebase that goes the same way as them

[EngrPips]

Below is my UniswapV2Arb1Test test exercise. I didnt need to change anything in the import because the test is importing only the interface of all the contracts needed in the process, and also the test process has provided the address of the needed contract on the ETH mainnet, so I need to complete the test and run a process that forks the ETH mainnet chain.

You only need to install all the required packages in your lib folder and change your import path as necessary if you want the test exercise process to run locally.

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {Test, console2} from "forge-std/Test.sol";
import {IERC20} from "../../../src/interfaces/IERC20.sol";
import {IWETH} from "../../../src/interfaces/IWETH.sol";
import {IUniswapV2Router02} from "../lib/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {
    DAI,
    WETH,
    UNISWAP_V2_ROUTER_02,
    SUSHISWAP_V2_ROUTER_02,
    UNISWAP_V2_PAIR_DAI_WETH,
    UNISWAP_V2_PAIR_DAI_MKR
} from "../../../src/Constants.sol";
import {UniswapV2Arb1} from "../src/UniswapV2Arb1.sol";

// Test arbitrage between Uniswap and Sushiswap
// Buy WETH on Uniswap, sell on Sushiswap.
// For flashSwap, borrow DAI from DAI/MKR pair
contract UniswapV2Arb1Test is Test {
    IUniswapV2Router02 private constant uni_router =
        IUniswapV2Router02(UNISWAP_V2_ROUTER_02);
    IUniswapV2Router02 private constant sushi_router =
        IUniswapV2Router02(SUSHISWAP_V2_ROUTER_02);
    IERC20 private constant dai = IERC20(DAI);
    IWETH private constant weth = IWETH(WETH);
    address constant user = address(11);

    UniswapV2Arb1 private arb;

    function setUp() public {
        arb = new UniswapV2Arb1();

        // Setup - WETH cheaper on Uniswap than Sushiswap
        deal(address(this), 100 * 1e18);

        weth.deposit{value: 100 * 1e18}();
        weth.approve(address(uni_router), type(uint256).max);

        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = DAI;

        uni_router.swapExactTokensForTokens({
            amountIn: 100 * 1e18,
            amountOutMin: 1,
            path: path,
            to: user,
            deadline: block.timestamp
        });

        // Setup - user has DAI, approves arb to spend DAI
        deal(DAI, user, 10000 * 1e18);
        vm.prank(user);
        dai.approve(address(arb), type(uint256).max);
    }

    function test_swap() public {
        uint256 bal0 = dai.balanceOf(user);
        vm.prank(user);
        arb.swap(
            UniswapV2Arb1.SwapParams({
                router0: UNISWAP_V2_ROUTER_02,
                router1: SUSHISWAP_V2_ROUTER_02,
                tokenIn: DAI,
                tokenOut: WETH,
                amountIn: 10000 * 1e18,
                minProfit: 1
            })
        );
        uint256 bal1 = dai.balanceOf(user);

        assertGe(bal1, bal0, "no profit");
        assertEq(dai.balanceOf(address(arb)), 0, "DAI balance of arb != 0");
        console2.log("profit", bal1 - bal0);
    }

    function test_flashSwap() public {
        uint256 bal0 = dai.balanceOf(user);
        vm.prank(user);
        arb.flashSwap(
            UNISWAP_V2_PAIR_DAI_MKR,
            true,
            UniswapV2Arb1.SwapParams({
                router0: UNISWAP_V2_ROUTER_02,
                router1: SUSHISWAP_V2_ROUTER_02,
                tokenIn: DAI,
                tokenOut: WETH,
                amountIn: 10000 * 1e18,
                minProfit: 1
            })
        );
        uint256 bal1 = dai.balanceOf(user);

        assertGe(bal1, bal0, "no profit");
        assertEq(dai.balanceOf(address(arb)), 0, "DAI balance of arb != 0");
        console2.log("profit", bal1 - bal0);
    }
}

Here is the solution

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {IUniswapV2Pair} from "lib/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import {IUniswapV2Router02} from "../lib/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {IERC20} from "../../../src/interfaces/IERC20.sol";

contract UniswapV2Arb1 {
    struct SwapParams {
        // Router to execute first swap - tokenIn for tokenOut
        address router0;
        // Router to execute second swap - tokenOut for tokenIn
        address router1;
        // Token in of first swap
        address tokenIn;
        // Token out of first swap
        address tokenOut;
        // Amount in for the first swap
        uint256 amountIn;
        // Revert the arbitrage if profit is less than this minimum
        uint256 minProfit;
    }

    function _swap(SwapParams memory params) private returns(uint256 amountOut) {
        // swap on router0
        // we approve the first router to take tokens from this contract
        IERC20(params.tokenIn).approve(params.router0, params.amountIn);

        // create path that will be used for the swap
        address[] memory swapPath = new address[](2);
        swapPath[0] = params.tokenIn;
        swapPath[1] = params.tokenOut;

        // we call the first router to swap tokens and get back the amount of token that went into the swap and the amount of token that came out of the token
        uint256[] memory firstAmounts = IUniswapV2Router02(params.router0).swapExactTokensForTokens({
            amountIn: params.amountIn,
            amountOutMin: 1,
            path: swapPath,
            to: address(this),
            deadline: block.timestamp
        }
        );

        // swap on router1
        // we approve the second router to take tokens from this contract
        IERC20(params.tokenOut).approve(params.router1, firstAmounts[1]);
        // we create path that we will use for the second swap
        address[] memory swapPath1 = new address[](2);
        swapPath1[0] = params.tokenOut;
        swapPath1[1] = params.tokenIn;

        // we call the second router to swap tokens and get back the amount of token that went into the swap and the amount of token that came out of the swap
        uint256[] memory secondAmounts = IUniswapV2Router02(params.router1).swapExactTokensForTokens({
            amountIn: firstAmounts[1],
            amountOutMin: 1,
            path: swapPath1,
            to: address(this),
            deadline: block.timestamp
        }
        );

        // we return the amount of tokens that cam out after the two swap
        amountOut = secondAmounts[1];
    }

    // Exercise 1
    // - Execute an arbitrage between router0 and router1
    // - Pull tokenIn from msg.sender
    // - Send amountIn + profit back to msg.sender
    function swap(SwapParams calldata params) external {
        // Write your code here
        // we transfer token from the user that wants to perform an arbitrage to this contract, the user had initially approve this contract to take token from them
        IERC20(params.tokenIn).transferFrom(msg.sender, address(this), params.amountIn);
        // we call the internal function which will perform the arbitrage and get backs the amount of token that is returned to this contract after the arbitrage 
        uint256 amountOut = _swap(params);
        // we ensure that the profit made after the arbitrage process meets the minimum profit the user is willing to accept
        require(amountOut - params.amountIn >= params.minProfit, "insufficient profit");
        // we send the amount of tokens received after the arbitrage process to the user
        IERC20(params.tokenIn).transfer(msg.sender, amountOut);
        // Don’t change any other code swapExactTokensForTokens
    }

    // Exercise 2
    // - Execute an arbitrage between router0 and router1 using flash swap
    // - Borrow tokenIn with flash swap from pair
    // - Send profit back to msg.sender
    /**
     * @param pair Address of pair contract to flash swap and borrow tokenIn
     * @param isToken0 True if token to borrow is token0 of pair
     * @param params Swap parameters
     */
    function flashSwap(address pair, bool isToken0, SwapParams calldata params)
        external
    {
        // Write your code here
        // we encode the data we send to the pair contract which will signify that we are requestion a flashloan from it and not a token swap
        bytes memory data = abi.encode(msg.sender, pair, params);
        IUniswapV2Pair(pair).swap({amount0Out: isToken0 ? params.amountIn: 0, amount1Out: isToken0 ? 0 : params.amountIn, to: address(this), data: data});
        // Don’t change any other code
    }

    function uniswapV2Call(
        address sender,
        uint256 amount0Out,
        uint256 amount1Out,
        bytes calldata data
    ) external {
        // Write your code here
        (address caller, address pair, SwapParams memory params) = abi.decode(data, (address, address, SwapParams));
        uint256 amountOut = _swap(params);
        uint256 fee = ((params.amountIn * 3) / 997) + 1;
        uint256 amountToRepay = params.amountIn + fee;
        uint256 profit = amountOut - amountToRepay;
        require(profit >= params.minProfit, "Insufficient profit");
        IERC20(params.tokenIn).transfer(address(pair), amountToRepay);
        IERC20(params.tokenIn).transfer(caller, profit);
        // Don’t change any other code
    }
}

[theblack2ke]

Thank you sir
That's what I needed

[EngrPips]

Any time, Friend.