Contract Address Details

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

/* 
 ┌────────────────────────────────────────────────────────────────────────┐
 │                                                                        │
 │                       ███████ ██    ██ ███    ██                       │
 │                       ██      ██    ██ ████   ██                       │
 │                       ███████ ██    ██ ██ ██  ██                       │
 │                            ██ ██    ██ ██  ██ ██                       │
 │                       ███████  ██████  ██   ████                       │
 │                                                                        │
 │                                                                        │
 │  Holding SUN gives you free reflections. MOON uses swap taxes to buy   │
 │  the tokens it’s paired with. Those tokens are automatically reflected │
 │  to SUN holders—connecting them with every project in MOON’s orbit.    │
 │                                                                        │
 │  SUN behavior                                                          │
 │   • Standard ERC-20: fixed supply, no fees, no taxes, no admin keys.   │
 │   • One addition: a lightweight post-transfer hook allows MOON to keep │
 │     it's reflection accounting precise.                                │
 │   • Holders may optionally call Moon.collect() to synchronize          │
 │     reflections at any time, though this is not required.              │
 │                                                                        │
 └────────────────────────────────────────────────────────────────────────┘
*/

/*────────────────────────────  INTERFACES  ───────────────────────────────*/

/// @notice Minimal ERC‑20 interface used by Sun.
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address owner) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/// @notice Moon’s hook; Sun notifies Moon before every balance‑changing transfer.
/// @dev    Moon uses these pre‑transfer balances to maintain its own accounting.
interface IMoon {
    function transferSun(address from, address to, uint256 fromBal, uint256 toBal, uint256 amount) external;
}

/*──────────────────────────────  CONTRACT  ───────────────────────────────*/

contract Sun is IERC20 {
    /*//////////////////////////////////////////////////////////////////////////
                                    METADATA
    //////////////////////////////////////////////////////////////////////////*/

    /// @notice ERC‑20 name.
    string  public constant name     = "Sun";
    /// @notice ERC‑20 symbol.
    string  public constant symbol   = "SUN";
    /// @notice ERC‑20 decimals (fixed at 18).
    uint8   public constant decimals = 18;

    /*//////////////////////////////////////////////////////////////////////////
                                   IMMUTABLES
    //////////////////////////////////////////////////////////////////////////*/

    /// @notice Fixed total supply (scaled by 1e18 in the constructor).
    uint256 public immutable override totalSupply;
    /// @notice The trusted Moon contract that receives transfer hooks.
    address public immutable moon;

    /*//////////////////////////////////////////////////////////////////////////
                               ERC-20 CORE STORAGE
    //////////////////////////////////////////////////////////////////////////*/

    /// @dev Balance mapping per ERC‑20.
    mapping(address => uint256) internal balances;
    /// @dev Allowance mapping per ERC‑20 (`owner => (spender => amount)`).
    mapping(address => mapping(address => uint256)) internal allowances;

    /*//////////////////////////////////////////////////////////////////////////
                                   CONSTRUCTOR
    //////////////////////////////////////////////////////////////////////////*/


    /// @param supply       Human‑readable supply (will be scaled by 1e18).
    /// @param moonAddress  The Moon contract to notify on transfers (must be non‑zero).
    /// Mints the entire fixed supply to `msg.sender`.
    constructor(uint256 supply, address moonAddress) {
        require(moonAddress != address(0), "Sun: zero Moon addr");
        moon = moonAddress;

        // Scale by 1e18 to align with `decimals = 18`.
        totalSupply = supply * 1e18;

        // Mint fixed supply to deployer.
        balances[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);
    }

    /*//////////////////////////////////////////////////////////////////////////
                               ERC-20 VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////////////////*/

    /// @notice Returns the current balance of an address.
    function balanceOf(address owner) public view override returns (uint256) {
        return balances[owner];
    }

    /// @notice Returns the remaining allowance from `owner` to `spender`.
    function allowance(address owner, address spender)
        public
        view
        override
        returns (uint256)
    {
        return allowances[owner][spender];
    }

    /*//////////////////////////////////////////////////////////////////////////
                         ERC-20 EXTERNAL MUTATIVE FUNCTIONS
    //////////////////////////////////////////////////////////////////////////*/

    /// @notice Sets `spender`’s allowance over the caller’s tokens to `amount`.
    /// Emits an {Approval} event.
    function approve(address spender, uint256 amount)
        external
        override
        returns (bool)
    {
        _approve(msg.sender, spender, amount);
        return true;
    }

    /// @notice Moves `amount` tokens from caller to `to`.
    /// Emits a {Transfer} event and **notifies Moon** before state changes.
    function transfer(address to, uint256 amount)
        external
        override
        returns (bool)
    {
        _transfer(msg.sender, to, amount);
        return true;
    }

    /// @notice Moves `amount` tokens from `from` to `to` using the caller’s allowance.
    /// Deducts allowance unless it is `type(uint256).max` (infinite allowance UX).
    /// Emits a {Transfer} event and **notifies Moon** before state changes.
    function transferFrom(address from, address to, uint256 amount)
        external
        override
        returns (bool)
    {
        uint256 cur = allowances[from][msg.sender];
        if (cur != type(uint256).max) {
            require(cur >= amount, "allowance");
            unchecked {
                allowances[from][msg.sender] = cur - amount;
            }
            emit Approval(from, msg.sender, cur - amount);
        }

        _transfer(from, to, amount);
        return true;
    }

    /*//////////////////////////////////////////////////////////////////////////
                          INTERNAL APPROVAL HELPER
    //////////////////////////////////////////////////////////////////////////*/

    /// @dev Internal setter for allowances; emits {Approval}.
    function _approve(address owner, address spender, uint256 amount) internal {
        allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /*//////////////////////////////////////////////////////////////////////////
                               INTERNAL TRANSFER
    //////////////////////////////////////////////////////////////////////////*/

    /// @dev Internal move of tokens with Moon transfer notification.
    /// Non‑standard behaviors (documented):
    /// - We call `Moon.transferSun` with pre‑transfer balances.
    function _transfer(address from, address to, uint256 amount) internal {
        // Standard ERC‑20 validations.
        require(to != address(0), "ERC20: transfer to the zero address");
        uint256 fromBal = balances[from];
        require(fromBal >= amount, "ERC20: transfer amount exceeds balance");
        uint256 toBal = balances[to];

        // Apply balance changes (unchecked is safe due to the require above).
        unchecked {
            balances[from] -= amount;
            balances[to]   += amount;
        }

        // Inform Moon of the transfer using pre‑transfer balances. Moon can
        // update reward indices, membership status, or any other accounting.
        IMoon(moon).transferSun(from, to, fromBal, toBal, amount);

        // Emit standard ERC‑20 Transfer event.
        emit Transfer(from, to, amount);
    }
}