// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * 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;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    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
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // 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;
    }
}

// Deployed with the Atlas IDE
// https://app.atlaszk.com/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

/**
 * @title CrustySwap MegaETH Bridge
 * https://www.crustyswap.com/
 * @dev Contract for depositing ETH to be bridged to another chain
 */
contract MegaETHBridge is ReentrancyGuard {
    // Events
    event Deposit(address indexed recipient, uint256 amount, uint256 timestamp);
    event MinimumDepositUpdated(uint256 oldMinimum, uint256 newMinimum);
    event Distribution(address indexed recipient, uint256 amount, uint256 timestamp);
    event ReferralPaid(address indexed referrer, address indexed depositor, uint256 amount);
    event ReferralShareUpdated(uint256 oldShare, uint256 newShare);
    event Withdrawal(address indexed owner, uint256 amount, uint256 timestamp);
    event PricePerETHUpdated(uint256 oldPrice, uint256 newPrice);
    event RelayerAdded(address indexed relayer, uint256 timestamp);
    event RelayerRemoved(address indexed relayer, uint256 timestamp);

    // State variables
    address public owner;
    mapping(address => bool) public relayers;
    bool public paused;
    uint256 public minimumDeposit;
    uint256 public referralShare; // Percentage of deposit paid to referrer (in basis points, e.g. 500 = 5%)
    uint256 public pricePerETH; // Price in USD cents per 1 ETH token (1e18 wei)
        // Stored as USD cents * 10^6 for precision (e.g., $0.05 = 5000000)

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

    modifier onlyRelayer() {
        require(relayers[msg.sender], "Only authorized relayers can call this function");
        _;
    }

    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }

    modifier onlyEOA() {
        require(msg.sender == tx.origin, "Only EOA can call this function");
        _;
    }

    /**
     * @dev Constructor sets the owner of the contract and default minimum deposit
     * @param _initialRelayers Array of addresses of the initial relayers that can distribute ETH
     */
    constructor(address[] memory _initialRelayers) {
        owner = msg.sender;

        require(_initialRelayers.length > 0, "At least one relayer must be specified");
        for (uint256 i = 0; i < _initialRelayers.length; i++) {
            require(_initialRelayers[i] != address(0), "Relayer cannot be zero address");
            relayers[_initialRelayers[i]] = true;
            emit RelayerAdded(_initialRelayers[i], block.timestamp);
        }

        paused = false;
        minimumDeposit = 0.0001 ether;
        referralShare = 2000;
        pricePerETH = 5000000000;
    }

    /**
     * @dev Function to deposit ETH to be bridged
     * The deposited ETH will be detected by off-chain relayers
     * Only callable from Externally Owned Accounts (EOAs)
     * @param referrer Address of the referrer who will receive a share of the deposit
     * @param recipient Address to which deliver the deposit on the destination chain
     */
    function deposit(address referrer, address recipient) external payable whenNotPaused onlyEOA nonReentrant {
        require(msg.value >= minimumDeposit, "Deposit amount below minimum");
        require(recipient != address(0), "Recipient cannot be zero address");

        uint256 referralAmount = 0;
        uint256 bridgeAmount = msg.value;

        // Process referral if a valid referrer is provided
        if (referrer != address(0) && referrer != msg.sender) {
            // Calculate referral amount (referralShare basis points of the deposit)
            referralAmount = (msg.value * referralShare) / 10000;

            // Adjust bridge amount
            bridgeAmount = msg.value - referralAmount;

            // Pay the referrer
            (bool success,) = payable(referrer).call{value: referralAmount}("");

            // If payment fails, keep the amount in the bridge
            if (success) {
                emit ReferralPaid(referrer, msg.sender, referralAmount);
            } else {
                bridgeAmount = msg.value;
                referralAmount = 0;
            }
        }

        // Emit event for the relayer to detect
        emit Deposit(recipient, msg.value, block.timestamp);
    }

    /**
     * @dev Function to distribute ETH to a recipient who sold ETH on the destination chain
     * Only authorized relayers can call this function
     * @param recipient Address to receive the ETH
     * @param amount Amount of ETH to distribute
     */
    function distributeEth(address recipient, uint256 amount) external onlyRelayer whenNotPaused nonReentrant {
        require(recipient != address(0), "Cannot distribute to zero address");
        require(amount > 0, "Amount must be greater than zero");
        require(address(this).balance >= amount, "Insufficient contract balance");

        // Transfer the ETH to the recipient
        (bool success,) = payable(recipient).call{value: amount}("");
        require(success, "Failed to send ETH");

        // Emit event for tracking
        emit Distribution(recipient, amount, block.timestamp);
    }

    /**
     * @dev Set the minimum deposit amount
     * @param _minimumDeposit New minimum deposit amount in wei
     */
    function setMinimumDeposit(uint256 _minimumDeposit) external onlyOwner {
        uint256 oldMinimum = minimumDeposit;
        minimumDeposit = _minimumDeposit;
        emit MinimumDepositUpdated(oldMinimum, _minimumDeposit);
    }

    /**
     * @dev Set the referral share percentage (in basis points)
     * @param _referralShare New referral share (e.g., 500 = 5%)
     */
    function setReferralShare(uint256 _referralShare) external onlyOwner {
        require(_referralShare <= 3000, "Referral share cannot exceed 30%");
        uint256 oldShare = referralShare;
        referralShare = _referralShare;
        emit ReferralShareUpdated(oldShare, _referralShare);
    }

    /**
     * @dev Set the price per ETH token in USD
     * @param _pricePerETH New price in USD cents * 10^6 per 1 ETH token (e.g., $0.05 = 5000000)
     */
    function setPricePerETH(uint256 _pricePerETH) external onlyOwner {
        require(_pricePerETH > 0, "Price must be greater than zero");
        uint256 oldPrice = pricePerETH;
        pricePerETH = _pricePerETH;
        emit PricePerETHUpdated(oldPrice, _pricePerETH);
    }

    /**
     * @dev Function to add a new relayer
     * Only the owner can call this function
     * @param _relayer Address of the new relayer
     */
    function addRelayer(address _relayer) external onlyOwner {
        require(_relayer != address(0), "Relayer cannot be zero address");
        require(!relayers[_relayer], "Address is already a relayer");

        relayers[_relayer] = true;
        emit RelayerAdded(_relayer, block.timestamp);
    }

    /**
     * @dev Function to remove a relayer
     * Only the owner can call this function
     * @param _relayer Address of the relayer to remove
     */
    function removeRelayer(address _relayer) external onlyOwner {
        require(relayers[_relayer], "Address is not a relayer");

        relayers[_relayer] = false;
        emit RelayerRemoved(_relayer, block.timestamp);
    }

    /**
     * @dev Check if an address is an authorized relayer
     * @param _address Address to check
     * @return bool indicating if the address is an authorized relayer
     */
    function isRelayer(address _address) external view returns (bool) {
        return relayers[_address];
    }

    /**
     * @dev Pause the contract
     */
    function setPaused(bool _paused) external onlyOwner {
        paused = _paused;
    }

    /**
     * @dev Allows the owner to withdraw a specific amount of funds
     * @param amount Amount of ETH to withdraw
     */
    function withdraw(uint256 amount) external onlyOwner nonReentrant {
        require(amount > 0, "Amount must be greater than zero");
        require(amount <= address(this).balance, "Insufficient contract balance");

        // Transfer the specified amount to the owner
        (bool success,) = payable(owner).call{value: amount}("");
        require(success, "Failed to send ETH");

        emit Withdrawal(owner, amount, block.timestamp);
    }

    /**
     * @dev Allows the owner to withdraw all funds
     */
    function withdrawAll() external onlyOwner nonReentrant {
        uint256 amount = address(this).balance;
        require(amount > 0, "No funds to withdraw");

        // Transfer all funds to the owner
        (bool success,) = payable(owner).call{value: amount}("");
        require(success, "Failed to send ETH");

        emit Withdrawal(owner, amount, block.timestamp);
    }

    /**
     * @dev Transfer ownership of the contract
     */
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "New owner cannot be zero address");
        owner = newOwner;
    }
}

{
  "compilationTarget": {
    "contracts/SourceBridge.sol": "MegaETHBridge"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    ":forge-std/=lib/forge-std/src/"
  ]
}