Reverting Transactions: Learning to use require

contract X {
  // shorthand!
  address owner = msg.sender;

  function ownerOnly() external {
    // REVERT if not the owner
    require(msg.sender == owner, "only owner!");
    // do something owner-y
  }
}

contract X {
  // @notice a non-privileged user attempted to access an admin-only method
  error Unauthorized();

  function adminOnly() external {
    if (!isAdmin(msg.sender)) {
      revert Unauthorized();
    }
  }
}

contract X {
  function withdraw() external {
    uint balance = getBalance(msg.sender);
    sendBalance(msg.sender);

    // they should not still have a balance!
    assert(getBalance(msg.sender) == 0);
  }
}

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

import "forge-std/console.sol";

// REVERT
// no state changes should have occured
// no value should have been transferred
// gas will still be paid for
contract A {
    address b;
    uint256 public errorsCount = 0;

    constructor(address _b) {
        b = _b;
    }

    function callB() external payable {
        (bool success, bytes memory returnData) = b.call{value: 1 ether}("");
        if (!success) {
            console.logBytes(returnData);
            console.logBytes32(keccak256("DoNotPayMe(uint256)"));
            errorsCount++;
        }
    }
}

contract B {
    uint256 public x = 0;
    // @notice nobody should ever pay this contract

    // 4 byte
    error DoNotPayMe(uint256);

    receive() external payable {
        x = 15;
        revert DoNotPayMe(msg.value);
    }
}

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

import "forge-std/Test.sol";
import "../src/Example.sol";

contract ExampleTest is Test {
    A public a;
    B public b;

    function setUp() public {
        b = new B();
        a = new A(address(b));
    }

    function testExample() public {
        a.callB{value: 1.5 ether}();
        assertEq(address(a).balance, 1.5 ether);
        assertEq(a.errorsCount(), 1);
        assertEq(b.x(), 0);
    }
}