Not related to the Foundry Course, another code i am working on personally

[heheboii11]

Hey everyone, i have been working on a small project. Have been facing this issue, when performing tests for swaping on uniswap V3 through swapRouter on forked ETH mainnet getting EVM Revert. Here is the code for my project and test file, sorry in advance for asking here

//SPDX-License-Identifier: MIT

pragma solidity 0.8.20;

import {ISwapRouter} from "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {RocketVaultWithdrawerInterface} from "lib/rocketpool/contracts/interface/RocketVaultWithdrawerInterface.sol";
import {RocketTokenRETHInterface} from "lib/rocketpool/contracts/interface/token/RocketTokenRETHInterface.sol";

contract RethEthBot {
    ISwapRouter public immutable swapRouter;
    RocketTokenRETHInterface public immutable reth;
    //address public immutable rocketPool;
    address private immutable i_owner;

    constructor(ISwapRouter _swapRouter, RocketTokenRETHInterface _reth) {
        swapRouter = _swapRouter;
        reth = _reth;
        //rocketPool = _rocketPool;
        i_owner = msg.sender;
    }

    modifier OnlyOwner() {
        require(msg.sender == i_owner, "Only owner can call this function");
        _;
    }

    function swapEthforReth(uint256 minOutput) external payable returns (uint256 Output) {
        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
            tokenIn: address(0),
            tokenOut: address(reth),
            fee: 3000,
            recipient: address(this),
            deadline: block.timestamp + 15 minutes,
            amountIn: msg.value,
            amountOutMinimum: minOutput,
            sqrtPriceLimitX96: 0
        });
        return swapRouter.exactInputSingle{value: msg.value}(params);
    }

    function withdrawRethForEth() external OnlyOwner {
        RocketTokenRETHInterface(reth).burn(reth.balanceOf(address(this)));
    }

    function withdrawEth() external OnlyOwner {
        payable(i_owner).transfer(address(this).balance);
    }

    function getRethAddress() external view returns (address) {
        return address(reth);
    }

    receive() external payable {}
}

Deploy script:

//SPDX-License_Identifier: MIT
pragma solidity 0.8.20;

import {Script} from "forge-std/Script.sol";
import {ISwapRouter} from "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import {RocketTokenRETHInterface} from "lib/rocketpool/contracts/interface/token/RocketTokenRETHInterface.sol";
import {RethEthBot} from "../src/RethEthBot.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract deployBot is Script {
    ISwapRouter public immutable swapRouter = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
    RocketTokenRETHInterface public immutable reth =
        RocketTokenRETHInterface(0xae78736Cd615f374D3085123A210448E74Fc6393);
    RethEthBot bot;

    function run() external returns (RethEthBot) {
        bot = new RethEthBot(swapRouter, reth);
        return (bot);
    }
}

And the Test file

//SPDX-License_Identifier: MIT

pragma solidity 0.8.20;

import {Test, console} from "forge-std/Test.sol";
import {deployBot} from "../script/deployBot.s.sol";
import {RethEthBot} from "../src/RethEthBot.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract TestBot is Test {
    RethEthBot bot;
    deployBot deploy;
    uint256 minOutput = 0;
    uint256 public constant ETH_VALUE = 2 ether;
    uint256 public constant InputAmount = 1e18;
    IERC20 WETH;
    IERC20 reth;

    function setUp() public {
        deploy = new deployBot();
        bot = deploy.run();
        reth = IERC20(bot.getRethAddress());
    }

    function testSwapEthForReth() public {
        console.log(address(msg.sender));
        console.log(address(this));
        console.log("senderEthBalance:", address(msg.sender).balance);
        console.log("contractEthBalance:", address(this).balance);
        uint256 output = bot.swapEthforReth{value: InputAmount}(minOutput);
        console.log("Reth balance: ", bot.reth().balanceOf(address(bot)));
        //assert()
    }
}

Error Stack:

Ran 1 test for test/RethBotTest.t.sol:TestBot
[FAIL: EvmError: Revert] testSwapEthForReth() (gas: 35707)
Logs:
  0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38
  0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496
  senderEthBalance: 79228162521839996328546940878
  contractEthBalance: 79228162514264337593543950335

Traces:
  [826241] TestBot::setUp()
    ├─ [436653] → new deployBot@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 2070 bytes of code
    ├─ [306080] deployBot::run()
    │   ├─ [273013] → new RethEthBot@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   └─ ← [Return] 1361 bytes of code
    │   └─ ← [Return] RethEthBot: [0x104fBc016F4bb334D775a19E8A6510109AC63E00]
    ├─ [168] RethEthBot::getRethAddress() [staticcall]
    │   └─ ← [Return] 0xae78736Cd615f374D3085123A210448E74Fc6393
    └─ ← [Stop] 

  [35707] TestBot::testSwapEthForReth()
    ├─ [0] console::log(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log(TestBot: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("senderEthBalance:", 79228162521839996328546940878 [7.922e28]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("contractEthBalance:", 79228162514264337593543950335 [7.922e28]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [17095] RethEthBot::swapEthforReth{value: 1000000000000000000}(0)
    │   ├─ [6938] 0xE592427A0AEce92De3Edee1F18E0157C05861564::exactInputSingle{value: 1000000000000000000}(ExactInputSingleParams({ tokenIn: 0x0000000000000000000000000000000000000000, tokenOut: 0xae78736Cd615f374D3085123A210448E74Fc6393, fee: 3000, recipient: 0x104fBc016F4bb334D775a19E8A6510109AC63E00, deadline: 1736529935 [1.736e9], amountIn: 1000000000000000000 [1e18], amountOutMinimum: 0, sqrtPriceLimitX96: 0 }))
    │   │   └─ ← [Revert] EvmError: Revert
    │   └─ ← [Revert] EvmError: Revert
    └─ ← [Revert] EvmError: Revert

[EngrPips]

Hello @heheboii11, This Github is primarily for helping people taking the course to unblock themselves. So I am sorry if I can't help, but EvmError: Revert will happen when you are calling a function that does not exist on a contract, or you are making a contract call to an address that isn't even a contract. You can debug your code for those conditions.

[chainflash]

great