Cryo Explorer 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;
    }
}

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

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

interface IUniswapV2Router02 {
    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}

/**
 * @title ASPYR Reflect Token (No Snapshot)
 * @notice 
 *  - Total supply = 50M (no future minting)
 *  - 4% reflection on each transfer (proportionally redistributed to all holders)
 *  - Two-of-two "multisig-like" for major actions (burning)
 *  - Supply-based 5-phase ICO
 *  - Optional addLiquidity to Uniswap/Sushi
 *  - Trustless 50/50 ETH split
 *
 *  This code is for DEMONSTRATION ONLY and NOT AUDITED.
 */
contract AspyrReflect is ReentrancyGuard {
    // -------------------------------------------------------
    // Basic Info
    // -------------------------------------------------------
    string private constant _NAME = "ASPYR Network";
    string private constant _SYMBOL = "ASPYR";
    uint8 private constant _DECIMALS = 18;

    // -------------------------------------------------------
    // Reflection Mechanics
    // -------------------------------------------------------
    uint256 private constant MAX = type(uint256).max;

    uint256 private constant _tTotal = 50_000_000 * 10**_DECIMALS;  // 50 million
    uint256 private _rTotal = (MAX - (MAX % _tTotal)); // reflection total

    // 4% reflection fee on each transfer
    uint256 public constant REFLECTION_FEE = 4; // in percent

    // Mapping of addresses' reflected balances
    mapping(address => uint256) private _rOwned;
    // Optional if you want to exclude certain addresses from fee or reflection
    // But let's keep it simple: everyone is included
    mapping(address => mapping(address => uint256)) private _allowances;

    // -------------------------------------------------------
    // Two-of-two Governance
    // -------------------------------------------------------
    address public owner1;
    address public owner2;

    bool public isBurnProposed;
    address public burnProposer;
    address public proposedBurnFrom;
    uint256 public proposedBurnAmount;

    modifier onlyOwners() {
        require(msg.sender == owner1 || msg.sender == owner2, "Not an authorized owner");
        _;
    }

    // -------------------------------------------------------
    // ICO Supply-Based Phases
    // (21M total if fully sold)
    // -------------------------------------------------------
    uint256[5] public phaseSupply = [
        5_000_000 * 10**_DECIMALS, 
        4_000_000 * 10**_DECIMALS, 
        3_000_000 * 10**_DECIMALS, 
        4_000_000 * 10**_DECIMALS, 
        5_000_000 * 10**_DECIMALS
    ];
    uint256[5] public phaseRate = [1000, 900, 800, 700, 600]; // tokens per ETH
    uint256 public currentPhase; // 0..4

    // -------------------------------------------------------
    // DEX Routers
    // -------------------------------------------------------
    IUniswapV2Router02 public uniswapRouter;
    IUniswapV2Router02 public sushiRouter;

    // -------------------------------------------------------
    // Constructor
    // -------------------------------------------------------
    constructor(
        address _owner1,
        address _owner2,
        address _uniswapRouter,
        address _sushiRouter
    ) {
        require(_owner1 != address(0), "Invalid owner1");
        require(_owner2 != address(0), "Invalid owner2");
        require(_uniswapRouter != address(0), "Invalid uniswap router");
        require(_sushiRouter != address(0), "Invalid sushi router");

        owner1 = _owner1;
        owner2 = _owner2;

        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        sushiRouter = IUniswapV2Router02(_sushiRouter);

        // Initially, all tokens belong to the contract
        // so _rOwned[contract] = reflection of total
        _rOwned[address(this)] = _rTotal;

        // currentPhase = 0
    }

    // -------------------------------------------------------
    // ERC20-Like Public Functions
    // -------------------------------------------------------
    function name() public pure returns (string memory) {
        return _NAME;
    }

    function symbol() public pure returns (string memory) {
        return _SYMBOL;
    }

    function decimals() public pure returns (uint8) {
        return _DECIMALS;
    }

    function totalSupply() public pure returns (uint256) {
        return _tTotal;
    }

    /**
     * @notice Returns the actual token balance of an account.
     */
    function balanceOf(address account) public view returns (uint256) {
        // Convert the reflected balance _rOwned[account] to the "true" token amount
        return tokenFromReflection(_rOwned[account]);
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    // Approve someone to spend your tokens
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    // Transfer from sender to recipient
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    // Transfer from 'from' to 'recipient' using allowance
    function transferFrom(
        address from,
        address recipient,
        uint256 amount
    ) public returns (bool) {
        _transfer(from, recipient, amount);

        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= amount, "transfer amount exceeds allowance");
        unchecked {
            _approve(from, msg.sender, currentAllowance - amount);
        }
        return true;
    }

    // -------------------------------------------------------
    // Reflection Internal Functions
    // -------------------------------------------------------
    /**
     * @dev Convert from "token amount" to reflection amount
     */
    function reflectionFromToken(uint256 tAmount) public view returns (uint256) {
        require(tAmount <= _tTotal, "Amount > total supply");
        uint256 currentRate = _getReflectionRate();
        return tAmount * currentRate;
    }

    /**
     * @dev Convert from reflection amount to "token" amount
     */
    function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
        require(rAmount <= _rTotal, "rAmount > _rTotal");
        uint256 currentRate = _getReflectionRate();
        return rAmount / currentRate;
    }

    function _getReflectionRate() private view returns (uint256) {
        // ratio of _rTotal / _tTotal
        return _rTotal / _tTotal;
    }

    /**
     * @dev Main transfer logic with reflection.
     */
    function _transfer(address sender, address recipient, uint256 tAmount) private {
        require(sender != address(0), "transfer from zero address");
        require(recipient != address(0), "transfer to zero address");
        require(tAmount > 0, "transfer amount > 0");

        // reflection rate
        uint256 currentRate = _getReflectionRate();

        // reflection of the token amount
        uint256 rAmount = tAmount * currentRate;

        // Reflection fee is 4%
        // tFee = tAmount * 4 / 100
        uint256 tFee = (tAmount * REFLECTION_FEE) / 100;
        // The net tokens that the recipient actually gets
        uint256 tTransferAmount = tAmount - tFee;

        // The reflection of the net tokens
        uint256 rFee = tFee * currentRate;
        uint256 rTransferAmount = rAmount - rFee;

        // sender loses rAmount from their reflection balance
        _rOwned[sender] -= rAmount;

        // recipient gains rTransferAmount
        _rOwned[recipient] += rTransferAmount;

        // The rFee must be "reflected" to all holders, i.e. we reduce _rTotal
        // This effectively distributes those tokens among all holders 
        // proportionally, because everyone's share of the total reflection 
        // supply increases.
        _rTotal -= rFee;

        emit Transfer(sender, recipient, tTransferAmount);
        // If you want to show the "fee" as well, some tokens also do:
        // emit Transfer(sender, address(0), tFee);
        // but typically reflection does not use a separate address for the fee
    }

    /**
     * @dev Approve logic
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) private {
        require(owner != address(0), "approve from zero addr");
        require(spender != address(0), "approve to zero addr");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    // -------------------------------------------------------
    // Two-of-two Burn Logic
    // -------------------------------------------------------
    function proposeBurn(address from, uint256 tAmount) external onlyOwners {
        require(!isBurnProposed, "Burn proposal active");
        require(from != address(0), "Cannot burn from zero address");
        require(tAmount > 0, "Burn > 0");
        require(balanceOf(from) >= tAmount, "Insufficient balance to burn");

        burnProposer = msg.sender;
        proposedBurnFrom = from;
        proposedBurnAmount = tAmount;
        isBurnProposed = true;
    }

    function confirmBurn() external onlyOwners {
        require(isBurnProposed, "No burn proposal");
        require(msg.sender != burnProposer, "Same owner cannot confirm burn");

        // Convert tAmount to rAmount
        uint256 currentRate = _getReflectionRate();
        uint256 rAmount = proposedBurnAmount * currentRate;

        // remove from user
        _rOwned[proposedBurnFrom] -= rAmount;
        // reduce reflection total as well
        _rTotal -= rAmount;

        // effectively burned, because total supply remains the same,
        // but fewer reflected tokens remain in circulation
        // If you want to reduce total supply as well, you'd reduce _tTotal, 
        // but that complicates reflection math. We'll do it here to truly 
        // lower total supply:

        // reduce the actual total supply
        // note: this changes reflection rate, which can cause weird rounding
        // in a typical reflection token, burning might just remove from rTotal 
        // but let's do a full supply shrink:
        // _tTotal -= proposedBurnAmount;

        // Because we want "true" deflation, let's do it:
        // but we must ensure we can never go below 0
        // (not likely with these numbers)
        // We'll comment it out to keep reflection simpler.
        // _tTotal -= proposedBurnAmount;

        // final
        isBurnProposed = false;
        burnProposer = address(0);
        proposedBurnFrom = address(0);
        proposedBurnAmount = 0;

        emit Transfer(proposedBurnFrom, address(0), 0); // some tokens emit a Burn event
    }

    // -------------------------------------------------------
    // Supply-Based 5-Phase ICO
    // (21M tokens if fully sold out)
    // -------------------------------------------------------
    /**
     * @dev Similar logic as in prior examples: each phase has a supply and rate.
     * We store the tokens for sale in the contract's reflection balance.
     * Because reflection is ongoing, we just track a "phase supply" in terms 
     * of token units, not reflection.
     */
    function buyTokens() external payable nonReentrant {
        require(currentPhase < 5, "All ICO phases ended");
        require(msg.value > 0, "No ETH sent");

        uint256 leftoverEth = msg.value;
        uint256 tokensPurchasedTotal = 0;

        while (leftoverEth > 0 && currentPhase < 5) {
            uint256 rate = phaseRate[currentPhase];
            uint256 possibleTokens = leftoverEth * rate;
            // how many tokens remain in this phase
            uint256 phaseLeft = phaseSupply[currentPhase];

            if (possibleTokens <= phaseLeft) {
                // can fill entirely in this phase
                phaseSupply[currentPhase] -= possibleTokens;
                tokensPurchasedTotal += possibleTokens;
                leftoverEth = 0;
            } else {
                // user wants more tokens than remain
                tokensPurchasedTotal += phaseLeft;
                leftoverEth -= (phaseLeft / rate); 
                phaseSupply[currentPhase] = 0;
                currentPhase++;
            }
        }

        require(tokensPurchasedTotal > 0, "No tokens purchased");

        // Transfer from contract (reflection) to user
        _tokenTransferFromContract(msg.sender, tokensPurchasedTotal);

        // Refund leftover if phases are done
        if (leftoverEth > 0 && currentPhase == 5) {
            payable(msg.sender).transfer(leftoverEth);
        }
    }

    // A helper to transfer from the contract's reflection balance
    // The contract holds "balanceOf(address(this))" tokens in reflection form
    function _tokenTransferFromContract(address recipient, uint256 tAmount) private {
        // convert tAmount -> rAmount
        uint256 currentRate = _getReflectionRate();
        uint256 rAmount = tAmount * currentRate;

        require(_rOwned[address(this)] >= rAmount, "Contract has insufficient tokens");

        _rOwned[address(this)] -= rAmount;
        _rOwned[recipient] += rAmount;

        emit Transfer(address(this), recipient, tAmount);
    }

    // -------------------------------------------------------
    // Trustless 50/50 ETH Split
    // -------------------------------------------------------
    function withdrawAndSplitETH() external onlyOwners nonReentrant {
        uint256 bal = address(this).balance;
        require(bal > 0, "No ETH to split");

        uint256 half = bal / 2;
        payable(owner1).transfer(half);
        payable(owner2).transfer(address(this).balance);
    }

    // -------------------------------------------------------
    // Provide Liquidity (Uniswap/Sushi)
    // Still requires matching ETH + tokens
    // -------------------------------------------------------
    function provideLiquidityUniswap(
        uint256 tAmount,
        uint256 ethAmount,
        address to
    ) external onlyOwners nonReentrant payable {
        require(msg.value >= ethAmount, "Not enough ETH");
        // convert tAmount -> rAmount
        uint256 currentRate = _getReflectionRate();
        uint256 rAmount = tAmount * currentRate;

        require(_rOwned[address(this)] >= rAmount, "Not enough tokens in contract reflection");

        // Deduct from contract
        _rOwned[address(this)] -= rAmount;
        // Approve the router
        _approveRouter(address(uniswapRouter), tAmount);

        // Transfer reflection from contract to this -> doesn't need a real transfer, 
        // we just reduce reflection from contract 
        // But the router needs the actual tokens, so we do a trick:
        // We temporarily set a local "virtual" balance. In a real reflection token, 
        // you'd do a more complex approach or maintain a separate zero-fee approach 
        // for liquidity. This is simplified:

        // We'll do a direct approach:
        // 1. Increase recipient's reflection
        _rOwned[address(this)] += rAmount; // revert the removal
        // 2. Temporarily remove reflection fees for this operation? 
        // (common reflection tokens often exclude the router from fees)
        // For simplicity, let's do a direct approach:
        _transferNoFee(address(this), address(uniswapRouter), tAmount);

        uniswapRouter.addLiquidityETH{value: ethAmount}(
            address(this), // token
            tAmount,
            0, // min token
            0, // min ETH
            to,
            block.timestamp
        );

        // Refund leftover
        uint256 leftover = address(this).balance;
        if (leftover > 0) {
            payable(msg.sender).transfer(leftover);
        }
    }

    function provideLiquiditySushi(
        uint256 tAmount,
        uint256 ethAmount,
        address to
    ) external onlyOwners nonReentrant payable {
        require(msg.value >= ethAmount, "Not enough ETH");
        uint256 currentRate = _getReflectionRate();
        uint256 rAmount = tAmount * currentRate;
        require(_rOwned[address(this)] >= rAmount, "Not enough tokens in reflection");

        // Approve sushi
        _approveRouter(address(sushiRouter), tAmount);

        // Similarly do a no-fee transfer for the liquidity
        _transferNoFee(address(this), address(sushiRouter), tAmount);

        sushiRouter.addLiquidityETH{value: ethAmount}(
            address(this),
            tAmount,
            0,
            0,
            to,
            block.timestamp
        );

        // Refund leftover
        uint256 leftover = address(this).balance;
        if (leftover > 0) {
            payable(msg.sender).transfer(leftover);
        }
    }

    // This helper bypasses reflection fee so we can deposit exactly tAmount
    // from the contract to the router. It's a simplified approach.
    function _transferNoFee(address sender, address recipient, uint256 tAmount) private {
        uint256 senderRBalance = _rOwned[sender];
        uint256 currentRate = _getReflectionRate();
        uint256 rAmount = tAmount * currentRate;
        require(senderRBalance >= rAmount, "insufficient reflection balance");

        _rOwned[sender] -= rAmount;
        _rOwned[recipient] += rAmount;

        emit Transfer(sender, recipient, tAmount);
    }

    function _approveRouter(address router, uint256 tAmount) private {
        // We pretend "allowance" is infinite for the router in reflection.
        // In a typical reflection token, you'd maintain an internal `_allowances` 
        // mapping of the "true" token amounts. For demonstration, we set allowance 
        // to tAmount for the router. Then the router can take exactly tAmount from address(this).
        _allowances[address(this)][router] = tAmount;
        emit Approval(address(this), router, tAmount);
    }

    // -------------------------------------------------------
    // Receive / Fallback
    // -------------------------------------------------------
    receive() external payable {
        // accept ETH
    }

    fallback() external payable {
        revert("fallback not supported");
    }

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