Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

pragma solidity ^0.8.12;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title EthSplitV1
 * @notice Accepts ETH donations, splits out a platform fee, forwards the remainder to the charity, and emits an event.
 */
contract EthSplitV1 is ReentrancyGuard {
    address payable public feeRecipient;
    uint256 public feeBasisPoints;
    uint256 public constant BASIS_POINTS = 10_000;

    /// @dev Emitted when the fee basis points is updated
    event FeeUpdated(uint256 newFeeBasisPoints);

    /**
     * @dev
     * {
     *   "name": "DonationForwarded",
     *   "type": "event",
     *   "anonymous": false,
     *   "inputs": [
     *     { "type": "address",   "name": "donor",      "indexed": true  },
     *     { "type": "address",   "name": "charity",    "indexed": true  },
     *     { "type": "uint256",   "name": "fullAmount", "indexed": false },
     *     { "type": "uint256",   "name": "netAmount",  "indexed": false },
     *     { "type": "uint256",   "name": "fee",        "indexed": false }
     *   ]
     * }
     */
    event DonationForwarded(
        address indexed donor,
        address indexed charity,
        uint256 fullAmount,
        uint256 netAmount,
        uint256 fee
    );

    modifier onlyAdmin() {
        require(msg.sender == feeRecipient, "Not authorized");
        _;
    }

    /**
     * @param _feeRecipient          Wallet that captures the fee
     * @param _initialFeeBasisPoints Fee in basis points (0–10000)
     */
    constructor(address payable _feeRecipient, uint256 _initialFeeBasisPoints) {
        require(_feeRecipient != address(0), "Invalid fee recipient");
        require(_initialFeeBasisPoints <= BASIS_POINTS, "Fee > 100%");
        feeRecipient = _feeRecipient;
        feeBasisPoints = _initialFeeBasisPoints;
    }

    /**
     * @notice Updates the platform fee
     * @param _bps New fee in basis points
     */
    function updateFee(uint256 _bps) external onlyAdmin {
        require(_bps <= BASIS_POINTS, "Fee > 100%");
        feeBasisPoints = _bps;
        emit FeeUpdated(_bps);
    }

    receive() external payable {}

    /**
     * @notice Accepts ETH ⇒ splits out fee ⇒ forwards remainder ⇒ emits DonationForwarded
     * @param charity Receiver of net donation
     */
    function donate(address payable charity) external payable nonReentrant {
        require(msg.value > 0, "Must send ETH");
        require(charity != address(0), "Invalid charity");

        uint256 fullAmount = msg.value;
        uint256 fee = (fullAmount * feeBasisPoints) / BASIS_POINTS;
        uint256 netAmount = fullAmount - fee;

        // 1) Pay platform fee
        (bool feeSent, ) = feeRecipient.call{value: fee}("");
        require(feeSent, "Fee transfer failed");

        // 2) Forward net remainder
        (bool netSent, ) = charity.call{value: netAmount}("");
        require(netSent, "Net transfer failed");

        emit DonationForwarded(msg.sender, charity, fullAmount, netAmount, fee);
    }
}