Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// https://x.com/MegaSwapERC
// https://megaswap.fun

import "../IncludeAll.sol";
import "../core/MegaSwapERC20.sol";
import "../security/Ownable.sol";

/**
 * MegaTokenV2Tax (launch-ready) - FIXED
 * - Starts with 15% buy / 20% sell / 0% transfer taxes
 * - Max tx = 0.2% of total supply; Max wallet = 2% of total supply
 * - Per-account tax exemptions & limit exemptions
 * - Multiple DEX pairs supported
 * - Trading toggle; limits only apply when tradingEnabled = true
 * - Safety caps: each tax leg <= 20%
 * 
 * FIX: Properly reference parent's totalSupply state variable and ensure it's set
 */
contract MegaTokenV2Tax is MegaSwapERC20, Ownable {
    // ----- constants / caps -----
    uint256 public constant MAX_TAX_BPS = 2000;     // 20%
    uint256 public constant BPS_DENOM = 10_000;

    // ----- tax config -----
    address public feeReceiver;
    uint256 public buyTaxBps;       // 0 - 2000
    uint256 public sellTaxBps;      // 0 - 2000
    uint256 public transferTaxBps;  // 0 - 2000
    bool    public taxEnabled = true;

    // ----- trading / limits -----
    bool    public tradingEnabled = false;
    bool    public limitsEnabled  = true;

    // Defaults requested: 0.2% tx, 2% wallet
    uint256 public maxTxBps     = 20;   // 0.20% of total supply
    uint256 public maxWalletBps = 200;  // 2.00% of total supply

    // ----- mappings -----
    mapping(address => bool) public isExemptFromTax;
    mapping(address => bool) public isExemptFromLimits;
    mapping(address => bool) public isPair;

    // ----- events -----
    event TaxesUpdated(uint256 buyBps, uint256 sellBps, uint256 transferBps);
    event TaxEnabled(bool enabled);
    event FeeReceiverUpdated(address indexed to);

    event TradingEnabled(bool enabled);
    event LimitsEnabled(bool enabled);
    event MaxTxUpdated(uint256 newMaxTxBps);
    event MaxWalletUpdated(uint256 newMaxWalletBps);

    event ExemptFromTax(address indexed user, bool exempt);
    event ExemptFromLimits(address indexed user, bool exempt);
    event PairSet(address indexed pair, bool isPair);

    constructor(
        uint256 initialSupply,
        address _feeReceiver
    ) MegaSwapERC20("MegaSwap", "MGAS") {
        require(_feeReceiver != address(0), "fee recv=0");
        feeReceiver = _feeReceiver;

        // Initial mints & exemptions for deployer/receiver
        isExemptFromTax[msg.sender] = true;
        isExemptFromTax[_feeReceiver] = true;
        isExemptFromLimits[msg.sender] = true;
        isExemptFromLimits[_feeReceiver] = true;

        // Default taxes: 15/20/0
        buyTaxBps = 1500;
        sellTaxBps = 2000;
        transferTaxBps = 0;

        _mint(msg.sender, initialSupply);
        
        // FIX: Ensure totalSupply is set (in case parent's _mint doesn't update it)
        if (totalSupply == 0) {
            totalSupply = initialSupply;
        }
        
        emit TaxesUpdated(buyTaxBps, sellTaxBps, transferTaxBps);
        emit FeeReceiverUpdated(_feeReceiver);
    }

    // ----------------- admin: taxes -----------------
    function setTaxes(uint256 _buyBps, uint256 _sellBps, uint256 _transferBps) external onlyOwner {
        require(_buyBps <= MAX_TAX_BPS && _sellBps <= MAX_TAX_BPS && _transferBps <= MAX_TAX_BPS, "tax too high");
        buyTaxBps = _buyBps;
        sellTaxBps = _sellBps;
        transferTaxBps = _transferBps;
        emit TaxesUpdated(_buyBps, _sellBps, _transferBps);
    }

    function setTaxEnabled(bool _enabled) external onlyOwner {
        taxEnabled = _enabled;
        emit TaxEnabled(_enabled);
    }

    function setFeeReceiver(address _feeReceiver) external onlyOwner {
        require(_feeReceiver != address(0), "zero addr");
        feeReceiver = _feeReceiver;
        emit FeeReceiverUpdated(_feeReceiver);
    }

    function setExemptFromTax(address account, bool exempt) external onlyOwner {
        isExemptFromTax[account] = exempt;
        emit ExemptFromTax(account, exempt);
    }

    // ----------------- admin: trading / limits -----------------
    function setTradingEnabled(bool _enabled) external onlyOwner {
        tradingEnabled = _enabled;
        emit TradingEnabled(_enabled);
    }

    function setLimitsEnabled(bool _enabled) external onlyOwner {
        limitsEnabled = _enabled;
        emit LimitsEnabled(_enabled);
    }

    // Reduce-only by default to avoid raising limits post-launch by mistake.
    function setMaxTxBps(uint256 newMaxTxBps) external onlyOwner {
        require(newMaxTxBps <= maxTxBps, "can only reduce");
        maxTxBps = newMaxTxBps;
        emit MaxTxUpdated(newMaxTxBps);
    }

    function setMaxWalletBps(uint256 newMaxWalletBps) external onlyOwner {
        require(newMaxWalletBps <= maxWalletBps, "can only reduce");
        maxWalletBps = newMaxWalletBps;
        emit MaxWalletUpdated(newMaxWalletBps);
    }

    function setExemptFromLimits(address account, bool exempt) external onlyOwner {
        isExemptFromLimits[account] = exempt;
        emit ExemptFromLimits(account, exempt);
    }

    function setPair(address pair, bool pairStatus) external onlyOwner {
        isPair[pair] = pairStatus;
        emit PairSet(pair, pairStatus);
    }

    // ----------------- internals - FIXED -----------------
    function _maxTxAmount() public view returns (uint256) {
        // Access totalSupply as state variable from parent
        return (totalSupply * maxTxBps) / BPS_DENOM;
    }

    function _maxWalletAmount() public view returns (uint256) {
        // Access totalSupply as state variable from parent
        return (totalSupply * maxWalletBps) / BPS_DENOM;
    }

    function _transfer(address from, address to, uint256 amount) internal override {
        // Before trading enabled: only owner can move tokens (airdrop/LP prep)
        if (!tradingEnabled) {
            require(owner == from || owner == to || isExemptFromLimits[from] || isExemptFromLimits[to], "trading not enabled");
        }

        // Enforce limits (only when enabled and non-exempt)
        if (limitsEnabled && tradingEnabled && !isExemptFromLimits[from] && !isExemptFromLimits[to]) {
            // Max tx
            require(amount <= _maxTxAmount(), "max tx exceeded");
            // Max wallet (skip if sending to pair; apply for normal receives)
            if (!isPair[to]) {
                require(balanceOf[to] + amount <= _maxWalletAmount(), "max wallet exceeded");
            }
        }

        // Apply tax
        if (!taxEnabled || isExemptFromTax[from] || isExemptFromTax[to] || amount == 0) {
            super._transfer(from, to, amount);
            return;
        }

        uint256 taxBps;
        if (isPair[from] && !isPair[to]) {
            // buy
            taxBps = buyTaxBps;
        } else if (!isPair[from] && isPair[to]) {
            // sell
            taxBps = sellTaxBps;
        } else {
            // wallet <-> wallet
            taxBps = transferTaxBps;
        }

        uint256 fee = (amount * taxBps) / BPS_DENOM;
        uint256 sendAmount = amount - fee;

        if (fee > 0) {
            super._transfer(from, feeReceiver, fee);
        }
        super._transfer(from, to, sendAmount);
    }
}

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

import "../interfaces/IERC20.sol";

contract MegaSwapERC20 is IERC20 {
    string public name;
    string public symbol;
    uint8 public immutable decimals = 18;

    uint256 public override totalSupply;
    mapping(address => uint256) public override balanceOf;
    mapping(address => mapping(address => uint256)) public override allowance;

    constructor(string memory _n, string memory _s) {
        name = _n;
        symbol = _s;
    }

    function transfer(address to, uint256 v) external override returns (bool) {
        _transfer(msg.sender, to, v);
        return true;
    }

    function approve(address s, uint256 v) external override returns (bool) {
        allowance[msg.sender][s] = v;
        emit Approval(msg.sender, s, v);
        return true;
    }

    function transferFrom(address f, address t, uint256 v) external override returns (bool) {
        uint256 a = allowance[f][msg.sender];
        require(a >= v, "allowance");
        if (a != type(uint256).max) {
            allowance[f][msg.sender] = a - v;
            emit Approval(f, msg.sender, allowance[f][msg.sender]);
        }
        _transfer(f, t, v);
        return true;
    }

    // 👇 make virtual so taxed token can override
    function _transfer(address f, address t, uint256 v) internal virtual {
        require(balanceOf[f] >= v, "bal");
        unchecked {
            balanceOf[f] -= v;
            balanceOf[t] += v;
        }
        emit Transfer(f, t, v);
    }

    function _mint(address to, uint256 v) internal {
        totalSupply += v;
        balanceOf[to] += v;
        emit Transfer(address(0), to, v);
    }

    function _burn(address from, uint256 v) internal {
        require(balanceOf[from] >= v, "bal");
        unchecked {
            balanceOf[from] -= v;
            totalSupply -= v;
        }
        emit Transfer(from, address(0), v);
    }
}

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


import "../security/Ownable.sol";
contract MegaSwapFactory is Ownable {
    address public feeTo;
    address public feeToSetter;
    mapping(address=>mapping(address=>address)) public getPair;
    address[] public allPairs;
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
    constructor(address _feeToSetter){ feeToSetter = _feeToSetter; }
    function allPairsLength() external view returns (uint) { return allPairs.length; }
    function setFeeTo(address _feeTo) external {
        require(msg.sender == feeToSetter, 'FORBIDDEN');
        feeTo = _feeTo;
    }
    function setFeeToSetter(address _feeToSetter) external {
        require(msg.sender == feeToSetter, 'FORBIDDEN');
        feeToSetter = _feeToSetter;
    }
    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, 'IDENTICAL_ADDRESSES');
        require(getPair[tokenA][tokenB] == address(0), 'PAIR_EXISTS');
        pair = address(uint160(uint(keccak256(abi.encode(tokenA, tokenB, block.timestamp)))));
        getPair[tokenA][tokenB] = pair;
        getPair[tokenB][tokenA] = pair;
        allPairs.push(pair);
        emit PairCreated(tokenA, tokenB, pair, allPairs.length);
    }
}

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


import "../interfaces/IERC20.sol";
import "../libraries/TransferHelper.sol";
contract MegaSwapPair {
    address public token0;
    address public token1;
    uint112 private reserve0;
    uint112 private reserve1;
    event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to);
    event Sync(uint112 reserve0, uint112 reserve1);
    constructor(address _token0, address _token1){ token0=_token0; token1=_token1; }
    function getReserves() public view returns (uint112, uint112) { return (reserve0, reserve1); }
    function _update(uint balance0, uint balance1) internal { reserve0 = uint112(balance0); reserve1 = uint112(balance1); emit Sync(reserve0,reserve1); }
    function swap(uint amount0Out, uint amount1Out, address to) external {
        require(amount0Out>0 || amount1Out>0, "insufficient out");
        if (amount0Out>0) TransferHelper.safeTransfer(token0, to, amount0Out);
        if (amount1Out>0) TransferHelper.safeTransfer(token1, to, amount1Out);
        (uint b0, uint b1) = (IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)));
        _update(b0, b1);
        emit Swap(msg.sender,0,0,amount0Out,amount1Out,to);
    }
}

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


import "../interfaces/IERC20.sol";
contract WETH is IERC20 {
    string public constant name = "Wrapped Ether"; string public constant symbol = "WETH"; uint8 public constant decimals = 18;
    uint256 public override totalSupply;
    mapping(address=>uint256) public override balanceOf;
    mapping(address=>mapping(address=>uint256)) public override allowance;
    event Deposit(address indexed dst, uint wad);
    event Withdrawal(address indexed src, uint wad);
    receive() external payable { deposit(); }
    function deposit() public payable { balanceOf[msg.sender]+=msg.value; totalSupply+=msg.value; emit Deposit(msg.sender,msg.value); emit Transfer(address(0),msg.sender,msg.value); }
    function withdraw(uint wad) public { require(balanceOf[msg.sender]>=wad, "bal"); balanceOf[msg.sender]-=wad; totalSupply-=wad; emit Withdrawal(msg.sender, wad); emit Transfer(msg.sender,address(0),wad); payable(msg.sender).transfer(wad); }
    function transfer(address to, uint v) external override returns(bool){ _transfer(msg.sender,to,v); return true; }
    function approve(address s, uint v) external override returns(bool){ allowance[msg.sender][s]=v; emit Approval(msg.sender,s,v); return true; }
    function transferFrom(address f, address t, uint v) external override returns(bool){
        uint a = allowance[f][msg.sender]; require(a>=v,"allowance");
        if(a!=type(uint).max){ allowance[f][msg.sender]=a-v; emit Approval(f,msg.sender,allowance[f][msg.sender]); }
        _transfer(f,t,v); return true;
    }
    function _transfer(address f,address t,uint v) internal { require(balanceOf[f]>=v,"bal"); unchecked{balanceOf[f]-=v; balanceOf[t]+=v;} emit Transfer(f,t,v); }
}

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

import "../interfaces/IERC20.sol";
import "../security/ReentrancyGuard.sol";
import "../security/Ownable.sol";

/**
 * @title AutoCompound
 * @notice Simple auto-compounding vault for single-sided staking (reward == stake token).
 * Users deposit the token, receive shares, and vault can auto-compound by claiming rewards and restaking.
 */
contract AutoCompound is ReentrancyGuard, Ownable {
    IERC20 public immutable token;     // staking & reward token
    uint256 public totalShares;
    mapping(address => uint256) public shares;

    event Deposit(address indexed user, uint256 amount, uint256 sharesMinted);
    event Withdraw(address indexed user, uint256 amount, uint256 sharesBurned);
    event Compound(uint256 harvested, uint256 newTotal);

    constructor(address _token) {
        token = IERC20(_token);
    }

    function balance() public view returns (uint256) {
        return token.balanceOf(address(this));
    }

    function toShares(uint256 amount) public view returns (uint256) {
        uint256 supply = totalShares;
        uint256 bal = balance();
        return (supply == 0 || bal == 0) ? amount : amount * supply / bal;
    }

    function toAmount(uint256 _shares) public view returns (uint256) {
        return totalShares == 0 ? 0 : _shares * balance() / totalShares;
    }

    function deposit(uint256 amount) external nonReentrant {
        require(amount > 0, "zero");
        uint256 s = toShares(amount);
        totalShares += s;
        shares[msg.sender] += s;
        require(token.transferFrom(msg.sender, address(this), amount), "transfer fail");
        emit Deposit(msg.sender, amount, s);
    }

    function withdraw(uint256 shareAmount) external nonReentrant {
        require(shareAmount > 0 && shares[msg.sender] >= shareAmount, "bad shares");
        uint256 amt = toAmount(shareAmount);
        shares[msg.sender] -= shareAmount;
        totalShares -= shareAmount;
        require(token.transfer(msg.sender, amt), "transfer fail");
        emit Withdraw(msg.sender, amt, shareAmount);
    }

    /// @notice Harvest and restake rewards; in this basic version, rewards are already in the contract (e.g., via manual funding or integrated strategy).
    function compound() external nonReentrant onlyOwner {
        // With a real strategy you'd collect external rewards here then add to vault.
        // In this simplified version, "compound" is a no-op, but we keep the hook & event.
        emit Compound(0, balance());
    }
}

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

import "../security/Ownable.sol";

interface IVotingEscrowLike {
    function locked(address user) external view returns (uint256);
    function totalSupply() external view returns (uint256);
}

/**
 * @title BoostCalculator
 * @notice Provides a user-specific boost multiplier in BPS based on veToken share.
 * Base = 1.0x (10_000). Max configurable (e.g., 2.5x = 25_000).
 */
contract BoostCalculator is Ownable {
    IVotingEscrowLike public ve;
    uint256 public baseBps = 10_000;     // 1.0x
    uint256 public maxBps  = 25_000;     // 2.5x cap

    event VotingEscrowSet(address ve);
    event ParamsSet(uint256 baseBps, uint256 maxBps);

    constructor(address _ve) {
        ve = IVotingEscrowLike(_ve);
        emit VotingEscrowSet(_ve);
    }

    function setVotingEscrow(address _ve) external onlyOwner {
        ve = IVotingEscrowLike(_ve);
        emit VotingEscrowSet(_ve);
    }

    function setParams(uint256 _baseBps, uint256 _maxBps) external onlyOwner {
        require(_baseBps >= 10_000, "base < 1.0x");
        require(_maxBps >= _baseBps, "max < base");
        baseBps = _baseBps;
        maxBps = _maxBps;
        emit ParamsSet(_baseBps, _maxBps);
    }

    /// @notice Returns a multiplier in BPS applied to user's stake (>= base, <= max).
    function boostBps(address user) external view returns (uint256) {
        if (address(ve) == address(0)) return 10_000;
        uint256 userLocked = ve.locked(user);
        uint256 veTotal = ve.totalSupply();
        if (veTotal == 0) return 10_000;

        // Example curve: base + min(maxBaseDelta, proportional share * (maxBaseDelta))
        // This yields smooth boost from 1.0x to max depending on user's share.
        uint256 maxDelta = maxBps - baseBps;
        uint256 shareBps = userLocked * 10_000 / veTotal;
        uint256 delta = (maxDelta * shareBps) / 10_000;
        return baseBps + delta;
    }
}

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

import "../security/Ownable.sol";

/**
 * @title EmissionSchedule
 * @notice Block-based schedule of rewardPerBlock phases.
 */
contract EmissionSchedule is Ownable {
    struct Phase {
        uint256 startBlock;       // inclusive
        uint256 rewardPerBlock;   // wei units (18 decimals if token has 18)
    }

    Phase[] public phases;

    event PhaseAdded(uint256 indexed index, uint256 startBlock, uint256 rewardPerBlock);
    event PhaseUpdated(uint256 indexed index, uint256 startBlock, uint256 rewardPerBlock);
    event PhasesCleared();

    function phasesLength() external view returns (uint256) {
        return phases.length;
    }

    function addPhase(uint256 startBlock, uint256 rewardPerBlock) external onlyOwner {
        if (phases.length > 0) {
            require(startBlock > phases[phases.length - 1].startBlock, "startBlock must increase");
        }
        phases.push(Phase({startBlock: startBlock, rewardPerBlock: rewardPerBlock}));
        emit PhaseAdded(phases.length - 1, startBlock, rewardPerBlock);
    }

    function updatePhase(uint256 index, uint256 startBlock, uint256 rewardPerBlock) external onlyOwner {
        require(index < phases.length, "bad index");
        if (index > 0) {
            require(startBlock > phases[index - 1].startBlock, "must be after prev");
        }
        if (index + 1 < phases.length) {
            require(startBlock < phases[index + 1].startBlock, "must be before next");
        }
        phases[index] = Phase({startBlock: startBlock, rewardPerBlock: rewardPerBlock});
        emit PhaseUpdated(index, startBlock, rewardPerBlock);
    }

    function clearPhases() external onlyOwner {
        delete phases;
        emit PhasesCleared();
    }

    /// @notice Reward per block for the current block.
    function currentRewardPerBlock() external view returns (uint256) {
        uint256 len = phases.length;
        if (len == 0) return 0;
        uint256 b = block.number;
        // Find the last phase with startBlock <= b
        // Small arrays expected; simple scan is fine. (Can binary search if huge)
        uint256 reward;
        for (uint256 i = 0; i < len; i++) {
            if (b >= phases[i].startBlock) {
                reward = phases[i].rewardPerBlock;
            } else {
                break;
            }
        }
        return reward;
    }
}

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

import "../interfaces/IERC20.sol";
import "../security/Ownable.sol";
import "../security/ReentrancyGuard.sol";

interface IEmissionSchedule {
    function currentRewardPerBlock() external view returns (uint256);
}

interface IBoostCalculator {
    function boostBps(address user) external view returns (uint256);
}

/**
 * @title LiquidityMining
 * @notice MasterChef-like rewards distributor with optional emission schedule + boosting.
 */
contract LiquidityMining is Ownable, ReentrancyGuard {
    struct PoolInfo {
        IERC20  lpToken;
        uint256 allocPoint;
        uint256 lastRewardBlock;
        uint256 accRewardPerShare; // 1e12 precision
    }

    struct UserInfo {
        uint256 amount;     // deposited LP
        uint256 rewardDebt; // user.rewardDebt accounts for accRewardPerShare * amount
    }

    IERC20 public immutable rewardToken;
    PoolInfo[] public poolInfo;
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    uint256 public totalAllocPoint;
    uint256 public startBlock;
    IEmissionSchedule public emission;        // optional (0 addr => fixed rpb)
    IBoostCalculator  public booster;         // optional
    uint256 public fixedRewardPerBlock;       // used when emission == 0

    uint256 private constant ACC_PRECISION = 1e12;
    uint256 public constant BOOST_BPS_DENOM = 10_000;

    event PoolAdded(uint256 indexed pid, address lp, uint256 allocPoint);
    event PoolSet(uint256 indexed pid, uint256 allocPoint);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event Harvest(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmissionSet(address emission);
    event BoosterSet(address booster);
    event FixedRpbSet(uint256 rpb);

    constructor(
        address _rewardToken,
        uint256 _startBlock,
        uint256 _fixedRewardPerBlock
    ) {
        rewardToken = IERC20(_rewardToken);
        startBlock = _startBlock;
        fixedRewardPerBlock = _fixedRewardPerBlock;
    }

    // ----- admin -----
    function setEmission(address _emission) external onlyOwner {
        emission = IEmissionSchedule(_emission);
        emit EmissionSet(_emission);
    }

    function setBooster(address _booster) external onlyOwner {
        booster = IBoostCalculator(_booster);
        emit BoosterSet(_booster);
    }

    function setFixedRewardPerBlock(uint256 _rpb) external onlyOwner {
        fixedRewardPerBlock = _rpb;
        emit FixedRpbSet(_rpb);
    }

    function addPool(uint256 allocPoint, address lpToken, bool withUpdate) external onlyOwner {
        if (withUpdate) massUpdatePools();
        uint256 last = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint += allocPoint;
        poolInfo.push(PoolInfo({
            lpToken: IERC20(lpToken),
            allocPoint: allocPoint,
            lastRewardBlock: last,
            accRewardPerShare: 0
        }));
        emit PoolAdded(poolInfo.length - 1, lpToken, allocPoint);
    }

    function setPool(uint256 pid, uint256 allocPoint, bool withUpdate) external onlyOwner {
        if (withUpdate) massUpdatePools();
        totalAllocPoint = totalAllocPoint - poolInfo[pid].allocPoint + allocPoint;
        poolInfo[pid].allocPoint = allocPoint;
        emit PoolSet(pid, allocPoint);
    }

    // ----- views -----
    function poolLength() external view returns (uint256) { return poolInfo.length; }

    function rewardPerBlock() public view returns (uint256) {
        if (address(emission) != address(0)) {
            return emission.currentRewardPerBlock();
        }
        return fixedRewardPerBlock;
    }

    function pendingReward(uint256 pid, address user) external view returns (uint256) {
        PoolInfo memory pool = poolInfo[pid];
        UserInfo memory u = userInfo[pid][user];
        uint256 acc = pool.accRewardPerShare;
        if (block.number > pool.lastRewardBlock && pool.lpToken.balanceOf(address(this)) != 0 && totalAllocPoint > 0) {
            uint256 rpb = rewardPerBlock();
            uint256 blocks = block.number - pool.lastRewardBlock;
            uint256 reward = blocks * rpb * pool.allocPoint / totalAllocPoint;
            acc += reward * ACC_PRECISION / pool.lpToken.balanceOf(address(this));
        }
        uint256 basePending = u.amount * acc / ACC_PRECISION - u.rewardDebt;
        if (address(booster) != address(0)) {
            uint256 boostBps = booster.boostBps(user);
            return (basePending * boostBps) / BOOST_BPS_DENOM;
        }
        return basePending;
    }

    // ----- internal reward update -----
    function massUpdatePools() public {
        uint256 len = poolInfo.length;
        for (uint256 pid = 0; pid < len; pid++) {
            updatePool(pid);
        }
    }

    function updatePool(uint256 pid) public {
        PoolInfo storage pool = poolInfo[pid];
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number <= pool.lastRewardBlock || lpSupply == 0 || totalAllocPoint == 0) {
            pool.lastRewardBlock = block.number > pool.lastRewardBlock ? block.number : pool.lastRewardBlock;
            return;
        }
        uint256 rpb = rewardPerBlock();
        uint256 blocks = block.number - pool.lastRewardBlock;
        uint256 reward = blocks * rpb * pool.allocPoint / totalAllocPoint;

        // Pull rewards from owner/treasury first, or pre-fund this contract.
        // For simplicity, we assume the rewardToken is pre-funded.
        // If you want minting, you can extend rewardToken to allow mint() by owner.
        require(rewardToken.transferFrom(owner, address(this), reward), "funding failed");

        pool.accRewardPerShare += reward * ACC_PRECISION / lpSupply;
        pool.lastRewardBlock = block.number;
    }

    // ----- user actions -----
    function deposit(uint256 pid, uint256 amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage u = userInfo[pid][msg.sender];
        updatePool(pid);

        // harvest pending
        if (u.amount > 0) {
            uint256 pending = u.amount * pool.accRewardPerShare / ACC_PRECISION - u.rewardDebt;
            if (address(booster) != address(0)) {
                uint256 b = IBoostCalculator(booster).boostBps(msg.sender);
                pending = pending * b / BOOST_BPS_DENOM;
            }
            if (pending > 0) {
                rewardToken.transfer(msg.sender, pending);
                emit Harvest(msg.sender, pid, pending);
            }
        }

        if (amount > 0) {
            pool.lpToken.transferFrom(msg.sender, address(this), amount);
            u.amount += amount;
        }
        u.rewardDebt = u.amount * pool.accRewardPerShare / ACC_PRECISION;
        emit Deposit(msg.sender, pid, amount);
    }

    function withdraw(uint256 pid, uint256 amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage u = userInfo[pid][msg.sender];
        require(u.amount >= amount, "insufficient");

        updatePool(pid);

        uint256 pending = u.amount * pool.accRewardPerShare / ACC_PRECISION - u.rewardDebt;
        if (address(booster) != address(0)) {
            uint256 b = IBoostCalculator(booster).boostBps(msg.sender);
            pending = pending * b / BOOST_BPS_DENOM;
        }
        if (pending > 0) {
            rewardToken.transfer(msg.sender, pending);
            emit Harvest(msg.sender, pid, pending);
        }

        if (amount > 0) {
            u.amount -= amount;
            pool.lpToken.transfer(msg.sender, amount);
        }
        u.rewardDebt = u.amount * pool.accRewardPerShare / ACC_PRECISION;
        emit Withdraw(msg.sender, pid, amount);
    }

    function harvest(uint256 pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage u = userInfo[pid][msg.sender];
        updatePool(pid);
        uint256 pending = u.amount * pool.accRewardPerShare / ACC_PRECISION - u.rewardDebt;
        if (address(booster) != address(0)) {
            uint256 b = IBoostCalculator(booster).boostBps(msg.sender);
            pending = pending * b / BOOST_BPS_DENOM;
        }
        u.rewardDebt = u.amount * pool.accRewardPerShare / ACC_PRECISION;
        if (pending > 0) {
            rewardToken.transfer(msg.sender, pending);
            emit Harvest(msg.sender, pid, pending);
        }
    }

    function emergencyWithdraw(uint256 pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage u = userInfo[pid][msg.sender];
        uint256 amount = u.amount;
        u.amount = 0;
        u.rewardDebt = 0;
        pool.lpToken.transfer(msg.sender, amount);
        emit EmergencyWithdraw(msg.sender, pid, amount);
    }
}

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


import "../interfaces/IERC20.sol";
import "../security/Ownable.sol";
import "../security/ReentrancyGuard.sol";
contract MasterChef is Ownable, ReentrancyGuard {
    IERC20 public rewardToken;
    uint256 public rewardPerBlock;
    uint256 public startBlock;
    constructor(address _rewardToken, uint256 _rewardPerBlock, uint256 _startBlock){
        rewardToken = IERC20(_rewardToken); rewardPerBlock=_rewardPerBlock; startBlock=_startBlock;
    }
}

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

contract MultiRewarder { }

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

import "../interfaces/IERC20.sol";
import "../security/Ownable.sol";

contract RewardDistributor is Ownable {
    IERC20 public immutable reward;

    event Distributed(address indexed to, uint256 amount);
    event BatchDistributed(uint256 count, uint256 total);

    constructor(address _reward) {
        reward = IERC20(_reward);
    }

    function distribute(address to, uint256 amount) external onlyOwner {
        require(reward.transfer(to, amount), "transfer failed");
        emit Distributed(to, amount);
    }

    function batchDistribute(address[] calldata to, uint256[] calldata amount) external onlyOwner {
        require(to.length == amount.length, "len mismatch");
        uint256 total;
        for (uint256 i = 0; i < to.length; i++) {
            require(reward.transfer(to[i], amount[i]), "transfer failed");
            total += amount[i];
        }
        emit BatchDistributed(to.length, total);
    }
}

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


import "../security/ReentrancyGuard.sol";
import "../security/Pausable.sol";
import "../interfaces/IERC20.sol";
contract StakingRewards is ReentrancyGuard, Pausable {
    IERC20 public stakingToken; IERC20 public rewardsToken;
    constructor(address _stakingToken, address _rewardsToken){ stakingToken=IERC20(_stakingToken); rewardsToken=IERC20(_rewardsToken); }
}

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

import "../interfaces/IERC20.sol";
import "../security/Ownable.sol";

/**
 * @title VestingSchedule
 * @notice Linear vesting with cliff; owner can create/revoke grants; beneficiary can claim vested.
 */
contract VestingSchedule is Ownable {
    IERC20 public immutable token;

    struct Grant {
        uint256 total;
        uint256 claimed;
        uint64  start;
        uint64  cliff;   // seconds after start
        uint64  duration; // total seconds
        bool    revoked;
    }

    mapping(address => Grant) public grants;

    event GrantCreated(address indexed user, uint256 total, uint64 start, uint64 cliff, uint64 duration);
    event Revoked(address indexed user, uint256 refund);
    event Claimed(address indexed user, uint256 amount);

    constructor(address _token) {
        token = IERC20(_token);
    }

    function createGrant(
        address user,
        uint256 total,
        uint64 start,
        uint64 cliff,
        uint64 duration
    ) external onlyOwner {
        require(grants[user].total == 0, "exists");
        require(duration > 0 && total > 0, "bad params");
        grants[user] = Grant({ total: total, claimed: 0, start: start, cliff: cliff, duration: duration, revoked: false });
        emit GrantCreated(user, total, start, cliff, duration);
    }

    function vested(address user, uint64 t) public view returns (uint256) {
        Grant memory g = grants[user];
        if (g.total == 0 || g.revoked) return 0;
        if (t < g.start + g.cliff) return 0;
        if (t >= g.start + g.duration) return g.total;
        uint256 elapsed = t - g.start;
        return g.total * elapsed / g.duration;
    }

    function claim() external {
        Grant storage g = grants[msg.sender];
        require(!g.revoked && g.total > 0, "no grant");
        uint256 v = vested(msg.sender, uint64(block.timestamp));
        uint256 releasable = v > g.claimed ? v - g.claimed : 0;
        require(releasable > 0, "nothing");
        g.claimed += releasable;
        require(token.transfer(msg.sender, releasable), "transfer failed");
        emit Claimed(msg.sender, releasable);
    }

    function revoke(address user) external onlyOwner {
        Grant storage g = grants[user];
        require(!g.revoked && g.total > 0, "bad");
        uint256 v = vested(user, uint64(block.timestamp));
        uint256 refundable = g.total - (v > g.claimed ? v : g.claimed);
        g.revoked = true;
        if (refundable > 0) {
            require(token.transfer(owner, refundable), "refund failed");
        }
        emit Revoked(user, refundable);
    }
}

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

contract YieldFarm { }

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


import "../core/MegaSwapERC20.sol";
contract GovernanceToken is MegaSwapERC20 {
    constructor() MegaSwapERC20("Governance Token","gMEGA") {}
    function mint(address to, uint amount) external { _mint(to, amount); }
}

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


import "../security/Ownable.sol";
contract Governor is Ownable {
    event ProposalCreated(uint256 id, string description);
    function propose(string calldata description) external onlyOwner returns(uint256 id){
        id = uint256(keccak256(abi.encode(description, block.timestamp)));
        emit ProposalCreated(id, description);
    }
}

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


import "../core/MegaSwapERC20.sol";
contract MegaToken is MegaSwapERC20 {
    constructor(uint256 supply) MegaSwapERC20("Mega Token","MEGA") { _mint(msg.sender, supply); }
}

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


import "../security/Ownable.sol";
contract Timelock is Ownable {
    mapping(bytes32=>uint256) public eta;
    uint256 public delay;
    constructor(address admin, uint256 _delay){ owner = admin; delay = _delay; }
}

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


import "../security/Ownable.sol";
import "../interfaces/IERC20.sol";
contract Treasury is Ownable {
    receive() external payable {}
    function sweep(address token, address to, uint amount) external onlyOwner {
        if (token == address(0)) { payable(to).transfer(amount); }
        else { IERC20(token).transfer(to, amount); }
    }
}

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


import "../security/Ownable.sol";
contract VotingEscrow is Ownable {
    mapping(address=>uint256) public locked;
    event Locked(address indexed user, uint256 amount, uint256 until);
    function lock(uint256 amount, uint256) external { locked[msg.sender]+=amount; emit Locked(msg.sender, amount, block.timestamp+365 days); }
}

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

/**
 * IncludeAll: pulls the whole repo into the compilation unit so Etherscan
 * shows every file in the verified source listing.
 * NOTE: Do NOT import the token file itself to avoid cycles.
 */

// --- core ---
import "./core/MegaSwapERC20.sol";
import "./core/WETH.sol";
import "./core/MegaSwapFactory.sol";
import "./core/MegaSwapPair.sol";

// --- periphery ---
import "./periphery/MegaSwapRouter01.sol";
import "./periphery/MegaSwapRouter02.sol";
import "./periphery/FlashLoan.sol";
import "./periphery/SwapHelper.sol";

// --- governance ---
import "./governance/MegaToken.sol";
import "./governance/Governor.sol";
import "./governance/GovernanceToken.sol";
import "./governance/Treasury.sol";
import "./governance/Timelock.sol";
import "./governance/VotingEscrow.sol";

// --- farming ---
import "./farming/MasterChef.sol";
import "./farming/StakingRewards.sol";
import "./farming/YieldFarm.sol";
import "./farming/LiquidityMining.sol";
import "./farming/RewardDistributor.sol";
import "./farming/VestingSchedule.sol";
import "./farming/BoostCalculator.sol";
import "./farming/EmissionSchedule.sol";
import "./farming/MultiRewarder.sol";
import "./farming/AutoCompound.sol";

// --- oracle ---
import "./oracle/PriceOracle.sol";
import "./oracle/TWAPOracle.sol";
import "./oracle/ChainlinkPriceOracle.sol";
import "./oracle/Oracle4.sol";
import "./oracle/Oracle5.sol";
import "./oracle/Oracle6.sol";
import "./oracle/Oracle7.sol";
import "./oracle/Oracle8.sol";
import "./oracle/Oracle9.sol";
import "./oracle/Oracle10.sol";

// --- libraries ---
import "./libraries/TransferHelper.sol";
import "./libraries/UQ112x112.sol";
import "./libraries/MegaSwapLibrary.sol";

// --- security ---
import "./security/Ownable.sol";
import "./security/ReentrancyGuard.sol";
import "./security/Pausable.sol";
import "./security/AccessControl.sol";

// --- interfaces ---
import "./interfaces/IERC20.sol";
import "./interfaces/IMegaSwapFactory.sol";
import "./interfaces/IMegaSwapPair.sol";
import "./interfaces/IMegaSwapRouter01.sol";
import "./interfaces/IMegaSwapRouter02.sol";
import "./interfaces/IMegaSwapCallee.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/ICustom1.sol";
import "./interfaces/ICustom2.sol";
import "./interfaces/ICustom3.sol";
import "./interfaces/ICustom4.sol";
import "./interfaces/ICustom5.sol";
import "./interfaces/ICustom6.sol";
import "./interfaces/ICustom7.sol";
import "./interfaces/ICustom8.sol";
import "./interfaces/ICustom9.sol";
import "./interfaces/ICustom10.sol";

// --- tokens ---
import "./tokens/MegaUSD.sol";
import "./tokens/TestToken1.sol";
import "./tokens/TestToken2.sol";
import "./tokens/TestToken3.sol";
import "./tokens/TestToken4.sol";
import "./tokens/TestToken5.sol";
import "./tokens/TestToken6.sol";
import "./tokens/TestToken7.sol";
import "./tokens/TestToken8.sol";
import "./tokens/TestToken9.sol";
import "./tokens/TestToken10.sol";
import "./tokens/TestToken11.sol";
import "./tokens/TestToken12.sol";
import "./tokens/TestToken13.sol";
import "./tokens/TestToken14.sol";
import "./tokens/TestToken15.sol";

// --- utils ---
import "./utils/Multicall.sol";
import "./utils/BatchTransfer.sol";
import "./utils/FeeCollector.sol";
import "./utils/AddressBook.sol";
import "./utils/Utility5.sol";
import "./utils/Utility6.sol";
import "./utils/Utility7.sol";
import "./utils/Utility8.sol";
import "./utils/Utility9.sol";
import "./utils/Utility10.sol";
import "./utils/Utility11.sol";
import "./utils/Utility12.sol";
import "./utils/Utility13.sol";
import "./utils/Utility14.sol";
import "./utils/Utility15.sol";

// --- mocks ---
import "./mocks/Mock1.sol";
import "./mocks/Mock2.sol";
import "./mocks/Mock3.sol";
import "./mocks/Mock4.sol";
import "./mocks/Mock5.sol";
import "./mocks/Mock6.sol";
import "./mocks/Mock7.sol";
import "./mocks/Mock8.sol";
import "./mocks/Mock9.sol";
import "./mocks/Mock10.sol";
import "./mocks/Mock11.sol";
import "./mocks/Mock12.sol";
import "./mocks/Mock13.sol";
import "./mocks/Mock14.sol";
import "./mocks/Mock15.sol";
import "./mocks/Mock16.sol";
import "./mocks/Mock17.sol";
import "./mocks/Mock18.sol";
import "./mocks/Mock19.sol";
import "./mocks/Mock20.sol";

// --- migration ---
import "./migration/Migrator.sol";
import "./migration/LiquidityMigrator.sol";
import "./migration/Migration3.sol";
import "./migration/Migration4.sol";
import "./migration/Migration5.sol";

/* no code */

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

interface ICustom1 { function x() external view returns (uint); }

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

interface ICustom10 { function x() external view returns (uint); }

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

interface ICustom2 { function x() external view returns (uint); }

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

interface ICustom3 { function x() external view returns (uint); }

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

interface ICustom4 { function x() external view returns (uint); }

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

interface ICustom5 { function x() external view returns (uint); }

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

interface ICustom6 { function x() external view returns (uint); }

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

interface ICustom7 { function x() external view returns (uint); }

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

interface ICustom8 { function x() external view returns (uint); }

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

interface ICustom9 { function x() external view returns (uint); }

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


interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, 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);
}

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

interface IMegaSwapCallee { function megaswapCall(address sender,uint amount0,uint amount1,bytes calldata data) external; }

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

interface IMegaSwapFactory { function createPair(address, address) external returns(address); }

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

interface IMegaSwapPair { function getReserves() external view returns(uint112,uint112); }

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

interface IMegaSwapRouter01 { }

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

interface IMegaSwapRouter02 { }

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

interface IWETH { function deposit() external payable; function withdraw(uint) external; }

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


library MegaSwapLibrary {
    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
        require(amountA > 0, 'INSUFFICIENT_AMOUNT');
        require(reserveA > 0 && reserveB > 0, 'INSUFFICIENT_LIQUIDITY');
        amountB = (amountA * reserveB) / reserveA;
    }
}

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


library TransferHelper {
    function safeTransfer(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TRANSFER_FAILED');
    }
    function safeTransferFrom(address token, address from, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TRANSFER_FROM_FAILED');
    }
    function safeApprove(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'APPROVE_FAILED');
    }
}

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


library UQ112x112 {
    uint224 constant Q112 = 2**112;
    function encode(uint112 y) internal pure returns (uint224 z) { z = uint224(y) * Q112; }
    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) { z = x / uint224(y); }
}

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

contract LiquidityMigrator { }

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

contract Migration3 { }

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

contract Migration4 { }

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

contract Migration5 { }

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

contract Migrator { }

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

contract Mock1 { function id() external pure returns (uint) { return 1; } }

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

contract Mock10 { function id() external pure returns (uint) { return 10; } }

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

contract Mock11 { function id() external pure returns (uint) { return 11; } }

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

contract Mock12 { function id() external pure returns (uint) { return 12; } }

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

contract Mock13 { function id() external pure returns (uint) { return 13; } }

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

contract Mock14 { function id() external pure returns (uint) { return 14; } }

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

contract Mock15 { function id() external pure returns (uint) { return 15; } }

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

contract Mock16 { function id() external pure returns (uint) { return 16; } }

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

contract Mock17 { function id() external pure returns (uint) { return 17; } }

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

contract Mock18 { function id() external pure returns (uint) { return 18; } }

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

contract Mock19 { function id() external pure returns (uint) { return 19; } }

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

contract Mock2 { function id() external pure returns (uint) { return 2; } }

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

contract Mock20 { function id() external pure returns (uint) { return 20; } }

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

contract Mock3 { function id() external pure returns (uint) { return 3; } }

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

contract Mock4 { function id() external pure returns (uint) { return 4; } }

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

contract Mock5 { function id() external pure returns (uint) { return 5; } }

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

contract Mock6 { function id() external pure returns (uint) { return 6; } }

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

contract Mock7 { function id() external pure returns (uint) { return 7; } }

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

contract Mock8 { function id() external pure returns (uint) { return 8; } }

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

contract Mock9 { function id() external pure returns (uint) { return 9; } }

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

contract ChainlinkPriceOracle { address public feed; constructor(address _f){feed=_f;} }

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

contract Oracle10 { function peek() external pure returns(uint){ return 10; } }

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

contract Oracle4 { function peek() external pure returns(uint){ return 4; } }

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

contract Oracle5 { function peek() external pure returns(uint){ return 5; } }

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

contract Oracle6 { function peek() external pure returns(uint){ return 6; } }

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

contract Oracle7 { function peek() external pure returns(uint){ return 7; } }

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

contract Oracle8 { function peek() external pure returns(uint){ return 8; } }

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

contract Oracle9 { function peek() external pure returns(uint){ return 9; } }

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

contract PriceOracle { mapping(address=>uint) public price; function set(address t, uint p) external { price[t]=p; }}

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

contract TWAPOracle { }

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


contract FlashLoan {
    uint256 public feeBps = 9; // 0.09%
    event Borrow(address indexed borrower, address token, uint256 amount);
    function setFee(uint256 newFeeBps) external { feeBps = newFeeBps; }
    function borrow(address token, uint256 amount) external {
        emit Borrow(msg.sender, token, amount);
    }
}

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


import "../libraries/TransferHelper.sol";
import "../interfaces/IERC20.sol";
contract MegaSwapRouter01 {
    address public immutable factory;
    address public immutable WETH;
    constructor(address _factory, address _WETH){ factory = _factory; WETH=_WETH; }
    receive() external payable {}
    function swapExactETHForTokens(uint minOut, address tokenOut, address to) external payable {
        require(tokenOut != address(0) && to != address(0), "bad");
        emit SwapExecuted(msg.sender, tokenOut, msg.value, minOut, to);
    }
    event SwapExecuted(address indexed sender, address indexed tokenOut, uint amountIn, uint minOut, address to);
}

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


import "./MegaSwapRouter01.sol";
contract MegaSwapRouter02 is MegaSwapRouter01 {
    constructor(address _factory, address _WETH) MegaSwapRouter01(_factory,_WETH) {}
    function swapExactTokensForTokens(uint amountIn, uint minOut, address tokenIn, address tokenOut, address to) external {
        emit SwapTokensExecuted(msg.sender, tokenIn, tokenOut, amountIn, minOut, to);
    }
    event SwapTokensExecuted(address indexed sender, address tokenIn, address tokenOut, uint amountIn, uint minOut, address to);
}

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


library SwapHelper {
    function min(uint a, uint b) internal pure returns (uint) { return a < b ? a : b; }
}

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


contract AccessControl {
    mapping(bytes32=>mapping(address=>bool)) public hasRole;
    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
    event RoleGranted(bytes32 indexed role, address indexed account);
    modifier onlyRole(bytes32 r){ require(hasRole[r][msg.sender], "no role"); _; }
    constructor(){ hasRole[DEFAULT_ADMIN_ROLE][msg.sender]=true; }
    function grantRole(bytes32 r, address a) external onlyRole(DEFAULT_ADMIN_ROLE){ hasRole[r][a]=true; emit RoleGranted(r,a); }
}

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


contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() { owner = msg.sender; emit OwnershipTransferred(address(0), owner); }
    modifier onlyOwner() { require(msg.sender == owner, "not owner"); _; }
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "0 addr");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}

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

import "./Ownable.sol";

contract Pausable is Ownable {
    bool public paused;
    event Paused(bool status);

    function setPaused(bool _p) external onlyOwner {
        paused = _p;
        emit Paused(_p);
    }

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

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


abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;
    constructor() { _status = _NOT_ENTERED; }
    modifier nonReentrant() {
        require(_status != _ENTERED, "reentrant");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

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


import "../core/MegaSwapERC20.sol";
contract MegaUSD is MegaSwapERC20 { constructor() MegaSwapERC20("Mega USD","MUSD") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken1 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken1","TT1") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken10 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken10","TT10") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken11 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken11","TT11") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken12 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken12","TT12") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken13 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken13","TT13") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken14 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken14","TT14") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken15 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken15","TT15") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken2 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken2","TT2") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken3 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken3","TT3") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken4 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken4","TT4") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken5 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken5","TT5") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken6 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken6","TT6") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken7 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken7","TT7") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken8 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken8","TT8") { _mint(msg.sender, 1_000_000e18); } }

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


import "../core/MegaSwapERC20.sol";
contract TestToken9 is MegaSwapERC20 { constructor() MegaSwapERC20("TestToken9","TT9") { _mint(msg.sender, 1_000_000e18); } }

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

contract AddressBook { mapping(bytes32=>address) public book; function set(bytes32 k,address v) external { book[k]=v; } }

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

contract BatchTransfer { event Send(address to, uint amount); function batch(address[] calldata to, uint[] calldata amt) external { for(uint i;i<to.length;i++){ emit Send(to[i], amt[i]); } } }

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

contract FeeCollector { address public feeTo; function set(address a) external { feeTo=a; } }

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

contract Multicall {
    function aggregate(bytes[] calldata calls)
        external
        view
        returns (uint256 blockNumber, bytes[] memory returnData)
    {
        blockNumber = block.number;
        // create an empty dynamic array of bytes arrays
        // explicit return of the tuple (blockNumber, returnData)
        return (blockNumber, returnData);
    }
}

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

contract Utility10 { function ping() external pure returns (uint) { return 10; } }

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

contract Utility11 { function ping() external pure returns (uint) { return 11; } }

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

contract Utility12 { function ping() external pure returns (uint) { return 12; } }

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

contract Utility13 { function ping() external pure returns (uint) { return 13; } }

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

contract Utility14 { function ping() external pure returns (uint) { return 14; } }

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

contract Utility15 { function ping() external pure returns (uint) { return 15; } }

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

contract Utility5 { function ping() external pure returns (uint) { return 5; } }

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

contract Utility6 { function ping() external pure returns (uint) { return 6; } }

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

contract Utility7 { function ping() external pure returns (uint) { return 7; } }

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

contract Utility8 { function ping() external pure returns (uint) { return 8; } }

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

contract Utility9 { function ping() external pure returns (uint) { return 9; } }

{
  "optimizer": {
    "enabled": true,
    "runs": 500
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"_feeReceiver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"bool","name":"exempt","type":"bool"}],"name":"ExemptFromLimits","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"bool","name":"exempt","type":"bool"}],"name":"ExemptFromTax","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"FeeReceiverUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"LimitsEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxTxBps","type":"uint256"}],"name":"MaxTxUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxWalletBps","type":"uint256"}],"name":"MaxWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"bool","name":"isPair","type":"bool"}],"name":"PairSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"TaxEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"buyBps","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellBps","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"transferBps","type":"uint256"}],"name":"TaxesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"TradingEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BPS_DENOM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TAX_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxTxAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxWalletAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"s","type":"address"},{"internalType":"uint256","name":"v","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyTaxBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExemptFromLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExemptFromTax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitsEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTxBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWalletBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellTaxBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setExemptFromLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setExemptFromTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeReceiver","type":"address"}],"name":"setFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setLimitsEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxTxBps","type":"uint256"}],"name":"setMaxTxBps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxWalletBps","type":"uint256"}],"name":"setMaxWalletBps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"pairStatus","type":"bool"}],"name":"setPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setTaxEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buyBps","type":"uint256"},{"internalType":"uint256","name":"_sellBps","type":"uint256"},{"internalType":"uint256","name":"_transferBps","type":"uint256"}],"name":"setTaxes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setTradingEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"v","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"f","type":"address"},{"internalType":"address","name":"t","type":"address"},{"internalType":"uint256","name":"v","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferTaxBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000000000000000000000033b2e3c9fd0803ce80000000000000000000000000000008941eb851407695fdde4e574ca981ede9d09dae4

-----Decoded View---------------
Arg [0] : initialSupply (uint256): 1000000000000000000000000000
Arg [1] : _feeReceiver (address): 0x8941eB851407695fDDe4E574ca981EDe9d09dAE4

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Arg [1] : 0000000000000000000000008941eb851407695fdde4e574ca981ede9d09dae4