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";
import "./interfaces/IFlauntFactory.sol";
import "./interfaces/IFlauntRouter.sol";
import "./interfaces/IFlauntBondingPool.sol";

/**
 * @title FLAUNT_ROUTER
 * @dev Router contract for Flaunt Platform, implementing UUPS upgradeability and Ownable access control.
 */
contract FlauntRouter is ReentrancyGuard {
    bool private paused = false;
    uint256 private feeBalance;

    function pause(bool _status) external onlyOwner {
        paused = _status;
    }

    modifier isPaused() {
        require(paused == false, "Security pause");
        _;
    }

    function protcolAddress() private pure returns (IProtcolAddress) {
        return IProtcolAddress(0xC6B021DE4C4d0D2C07f847AdeEFC1dBc1B31f661);
    }

    function bondingPoolManager() private view returns (address) {
        return protcolAddress().getAddress(14);
    }

    function feeReceiver() private view returns (address) {
        return protcolAddress().getAddress(3);
    }

    function flauntUniswapV3Manager() private view returns (address) {
        return protcolAddress().getAddress(1);
    }

    function flauntLaunchPool() private view returns (address) {
        return protcolAddress().getAddress(8);
    }

    modifier onlyAuthorized() {
        require(
            msg.sender == protcolAddress().getAddress(0),
            "FLAUNT_ROUTER: Not authorized"
        );
        _;
    }
    modifier onlyOwner() {
        require(
            msg.sender == protcolAddress().getAddress(7),
            "Caller is not the owner"
        );
        _;
    }
    /**
     * @notice Ensures that the transaction is executed before the deadline.
     * @param deadline Unix timestamp after which the transaction will revert.
     */
    modifier ensure(uint256 deadline) {
        require(deadline >= block.timestamp, "FLAUNT_ROUTER: EXPIRED");
        _;
    }

    // Events for tracking buy and sell transactions with ETH value and referall code in bytes
    event BuyTokensWithETH(
        address indexed wallet,
        uint256 ethSpent,
        bytes8 ref
    );

    /**
     * @notice Swaps an exact amount of ETH for tokens.
     * @dev Only callable externally. Ensures the path length is 2 and starts with ETH.
     * @param tokenToBuy token addresse.
     * @param deadline Unix timestamp after which the transaction will revert.
     * @return status Array of amounts for each step in the path.
     */
    function swapExactETHForTokens(
        address tokenToBuy,
        uint256 deadline,
        uint256 minTokenAmountOut,
        bytes8 ref
    )
        public
        payable
        isPaused
        ensure(deadline)
        nonReentrant
        returns (bool status)
    {
        require(msg.value > 0, "Need to send ETH");

        address to = msg.sender;

        address bondingPool = bondingPoolManager();
        // Calculate fee and swap amount
        uint256 feeAmount = (msg.value * 1) / 100; // 1% fee
        uint256 swapAmount = msg.value - feeAmount;

        feeBalance += feeAmount;

        // Perform swap
        uint256 amountOut = getTokenAmountOut(swapAmount, tokenToBuy);

        _executeSwapETHForTokens(
            bondingPool,
            tokenToBuy,
            amountOut,
            to,
            swapAmount,
            minTokenAmountOut
        );

        if (ref != 0x0000000000000000) {
            emit BuyTokensWithETH(msg.sender, msg.value, ref);
        }

        return true;
    }

    // Internal helper to transfer ETH
    function _transferETH(address recipient, uint256 amount) internal {
        (bool success, ) = recipient.call{value: amount}("");
        require(success, "FLAUNT_ROUTER: ETH_TRANSFER_FAILED");
    }

    // Internal helper to execute the swap
    function _executeSwapETHForTokens(
        address bondingPool,
        address tokenOut,
        uint256 amountOut,
        address to,
        uint256 ethAmount,
        uint256 minTokenAmountOut // min user willing to get
    ) internal {
        IFlauntBondingPool(bondingPool).swap(
            tokenOut,
            0,
            amountOut,
            0,
            msg.sender,
            to,
            ethAmount,
            minTokenAmountOut
        );
    }

    /**
     * @notice Swaps an exact amount of tokens for ETH.
     * @dev Only callable externally. Ensures the path length is 2 and ends with ETH.
     * @param amountIn Amount of tokens to swap.
     * @param tokenToSell token addresses
     * @param deadline Unix timestamp after which the transaction will revert.
     */
    function swapExactTokensForETH(
        uint256 amountIn,
        address tokenToSell,
        uint256 deadline,
        uint256 minEthAmountOut // user min eth willing to get
    ) external isPaused ensure(deadline) nonReentrant returns (bool status) {
        require(amountIn > 0, "Need to sell tokens");
        address bondingPool = bondingPoolManager();

        address to = msg.sender;

        // Calculate amount out
        uint256 amountOut = getETHAmountOut(amountIn, tokenToSell);

        // Perform swap
        _executeSwapTokensForETH(
            bondingPool,
            tokenToSell,
            amountIn,
            amountOut,
            to,
            minEthAmountOut
        );

        return true;
    }

    // Internal helper to execute the swap
    function _executeSwapTokensForETH(
        address bondingPool,
        address tokenIn,
        uint256 amountIn,
        uint256 amountOut,
        address to,
        uint256 minEthAmountOut
    ) internal {
        IFlauntBondingPool(bondingPool).swap(
            tokenIn,
            amountIn,
            0,
            amountOut,
            msg.sender,
            to,
            0,
            minEthAmountOut
        );
    }

    /**
     * @notice Calculates the output amount for a given input.
     * @param tokenAmountIn Input amount.
     * @return amount Amount out.
     */
    function getETHAmountOut(
        uint tokenAmountIn,
        address token
    ) public view returns (uint256 amount) {
        // Get the bondingPool address using the library
        address bondingPool = protcolAddress().getAddress(14);

        // Token to ETH swap
        amount = IFlauntBondingPool(bondingPool).calculateSellToken(
            tokenAmountIn,
            token
        );
    }

    /**
     * @notice Calculates the output amount for a given input.
     * @param ethAmountIn Input amount.
     * @return amount Amount out.
     */
    function getTokenAmountOut(
        uint ethAmountIn,
        address token
    ) public view returns (uint256 amount) {
        // Get the bondingPool address using the library
        address bondingPool = protcolAddress().getAddress(14);
        // ETH to token swap
        amount = IFlauntBondingPool(bondingPool).calculateBuyToken(
            ethAmountIn,
            token
        );
    }

    /**
     * @notice Returns the ETH required to buy a given amount of tokens from bonding pool.
     * If requested tokenAmount exceeds remaining supply, it returns capped values.
     * @param tokenAmount The requested token amount (scaled to 1e18)
     * @param token The bonding pool token address
     * @return actualTokenAmount The final token amount used (may be capped)
     * @return ethRequired The ETH needed to buy the specified (or capped) token amount
     */
    function getETHRequiredForTokens(
        uint256 tokenAmount,
        address token
    ) external view returns (uint256 actualTokenAmount, uint256 ethRequired) {
        address bondingPool = bondingPoolManager();
        return
            IFlauntBondingPool(bondingPool).ethRequiredForTokens(
                tokenAmount,
                token
            );
    }

    /**
     * @notice Simulates how many tokens user would receive and the actual ETH required
     * @param ethAmount The ETH amount user intends to spend
     * @param token The token to simulate buy for
     * @return tokenAmount The amount of tokens receivable
     * @return adjustedETH The actual ETH that would be used for the purchase
     */
    function simulateBuyTokenOut(
        uint256 ethAmount,
        address token
    ) external view returns (uint256 tokenAmount, uint256 adjustedETH) {
        address bondingPool = bondingPoolManager();
        return
            IFlauntBondingPool(bondingPool).simulateBuyToken(ethAmount, token);
    }

    function executeTrade(
        address from,
        address token,
        address to,
        uint256 value,
        uint256 minAmountOut,
        uint256 refund
    ) public returns (bool) {
        require(
            msg.sender == bondingPoolManager(),
            "FLAUNT_ROUTER: NOT_ALLOWED"
        );

        if (token == address(0)) {
            require(
                value >= minAmountOut,
                "FLAUNT_ROUTER: MinAmountOut ETH not enough"
            );
            // Deduct 1% ETH fee before sending
            uint256 feeAmount = (value * 1) / 100; // 1% fee
            uint256 finalAmount = value - feeAmount; // Remaining ETH

            feeBalance += feeAmount;

            uint256 ethBalance = address(this).balance - feeBalance;

            require(finalAmount <= ethBalance, "FLAUNT_ROUTER: NO_ETH_BALANCE");
            // Send remaining ETH to recipient
            (bool success, ) = to.call{value: finalAmount}("");
            require(success, "FLAUNT_ROUTER: ETH_TRANSFER_FAILED");
        } else {
            require(
                value >= minAmountOut,
                "FLAUNT_ROUTER: MinAmountOut TOKEN not enough"
            );

            // Refund excess ETH first
            if (refund > 0) {
                (bool refundSuccess, ) = to.call{value: refund}("");
                require(refundSuccess, "FLAUNT_ROUTER: TOKEN_REFUND_FAILED");
            }

            // Then send tokens from bonding pool (router) to user
            bool success = IERC20token(token).transferFrom(from, to, value);
            require(success, "FLAUNT_ROUTER: ERC20_TRANSFER_FAILED");
        }

        return true;
    }

    function graduateToken(address _tokenTogradute) public isPaused {
        require(msg.sender == flauntUniswapV3Manager(), "not allowed");

        address bondingPool = bondingPoolManager();

        (
            ,
            ,
            uint256 totalCollected,
            bool liquidityAddedToUniswap,

        ) = IFlauntBondingPool(bondingPool).getPool(_tokenTogradute);

        require(!liquidityAddedToUniswap, "liq already added");
        require(totalCollected >= 5 ether, "not complete");

        IERC20token(_tokenTogradute).transfer(
            msg.sender,
            269_003_190 * 10 ** 18
        );

        uint256 creatorEthReward = 0.1 ether;
        uint256 liqAmount = 5 ether;

        (bool b, ) = flauntUniswapV3Manager().call{value: liqAmount}(""); // liquidty
        (bool c, ) = IERC20token(_tokenTogradute).creatorAddress().call{
            value: creatorEthReward
        }(""); // creator

        uint256 rest = totalCollected - liqAmount - creatorEthReward;

        feeBalance += rest;

        require(b, "FLAUNT_ROUTER: ETH_LIQUIDITY_TRANSFER_FAILED");
        require(c, "FLAUNT_ROUTER: ETH_CREATOR_TRANSFER_FAILED");

        IFlauntBondingPool(bondingPool).setLiquidityAddedToUniswap(
            _tokenTogradute
        );
    }

    /**
     * @notice Withdraws the accumulated fee balance to the owner's address.
     */
    function withdrawFees() external {
        require(feeBalance > 0, "FLAUNT_ROUTER: NO_FEES_AVAILABLE");
        address feeReceiverAddress = feeReceiver();
        require(msg.sender == feeReceiverAddress, "not allowed");
        uint256 amount = feeBalance;
        feeBalance = 0;
        (bool feeSuccess, ) = feeReceiverAddress.call{value: amount}("");
        require(feeSuccess, "FLAUNT_ROUTER: FEE_TRANSFER_FAILED");
    }

    function createLaunchPool(address _token) external {
        require(msg.sender == flauntLaunchPool(), "only launchpool");

        IERC20token(_token).transfer(
            msg.sender,
            IERC20token(_token).balanceOf(address(this))
        );
    }

    /**
     * @notice Fallback function to accept ETH.
     */
    receive() external payable {}

    /**
     * @notice Fallback function to accept ETH.
     */
    fallback() external payable {}

    

  
}

interface IFlauntLiquidityManager {
    function countSoldOut() external returns (uint256);
}

/**
 * @title IERC20token
 * @dev Minimal interface for ERC20 tokens used in FLAUNT_ROUTER.
 */
interface IERC20token {
    function creatorAddress() external returns (address);

    /**
     * @notice Transfers tokens from one address to another.
     * @param from Address to transfer tokens from.
     * @param to Address to transfer tokens to.
     * @param value Amount of tokens to transfer.
     * @return Success status.
     */
    function transferFrom(
        address from,
        address to,
        uint value
    ) external returns (bool);

    /**
     * @notice Transfers tokens to another address.
     * @param to Address to transfer tokens to.
     * @param value Amount of tokens to transfer.
     * @return Success status.
     */
    function transfer(address to, uint value) external returns (bool);

    /**
     * @notice Gets the token balance of a specific address.
     * @param account Address to query the balance of.
     * @return Token balance of the specified address.
     */
    function balanceOf(address account) external view returns (uint256);

    function approve(address spender, uint value) external returns (bool);
}

interface IProtcolAddress {
    function getAddress(uint8 index) external view returns (address addr);
}

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

interface IFlauntBondingPool {
    function getReserves(
        address token
    ) external view returns (uint256 _reserve0, uint256 _reserve1);

    function swap(
        address token,
        uint256 amountOftokensToSell,
        uint256 amountTokenOut,
        uint256 amountETHOut,
        address from,
        address to,
        uint256 ethValue,
        uint256 minAmountOut
    ) external payable;

    function calculateBuyToken(
        uint256 ethAmount,
        address tokenAddress
    ) external view returns (uint256 tokens);

    function calculateSellToken(
        uint256 tokensToSell,
        address tokenAddress
    ) external view returns (uint256 ethAmountOut);

    function simulateBuyToken(
        uint256 ethAmount,
        address tokenAddress
    ) external view returns (uint256 tokenAmount, uint256 adjustedETH);

    function ethRequiredForTokens(
        uint256 tokenAmount,
        address tokenAddress
    ) external view returns (uint256 actualTokenAmount, uint256 ethRequired);

    function getPool(
        address _token
    )
        external
        view
        returns (
            address token,
            uint256 totalSupply,
            uint256 totalCollected,
            bool liquidityAddedToUniswap,
            bool initialized
        );

    function setLiquidityAddedToUniswap(address _token) external;
}

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

interface IFlauntFactory {
    function launchToken(
        bytes calldata name_,
        bytes calldata symbol_,
        bytes calldata tokenURI,
        address creator,
        bytes calldata telegram_,
        bytes calldata twitter_,
        bytes calldata website_
    ) external payable;
}

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

interface IFlauntRouter {
    function swapExactETHForTokens(
        address[] calldata path,
        address to,
        uint256 deadline,
        bytes8 ref
    ) external payable returns (bool status);

    function swapExactTokensForETH(
        uint256 amountIn,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (bool status);

    function getEthAmountOut(
        uint ethAmountIn,
        address token
    ) external view returns (uint256 amount);

    function getTokenAmountOut(
        uint tokenAamountIn,
        address token
    ) external view returns (uint256 amount);
}