MegaTokenV2Tax

{{
  "language": "Solidity",
  "sources": {
    "contracts/core/MegaSwapERC20.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/core/MegaSwapFactory.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/core/MegaSwapPair.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/core/WETH.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/farming/AutoCompound.sol": {
      "content": "// 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());
    }
}
"
    },
    "contracts/farming/BoostCalculator.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/farming/EmissionSchedule.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/farming/LiquidityMining.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/farming/MasterChef.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/farming/MultiRewarder.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract MultiRewarder { }"
    },
    "contracts/farming/RewardDistributor.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/farming/StakingRewards.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/farming/VestingSchedule.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/farming/YieldFarm.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract YieldFarm { }"
    },
    "contracts/governance/GovernanceToken.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/governance/Governor.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/governance/MegaToken.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/governance/Timelock.sol": {
      "content": "// 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; }
}
"
    },
    "contracts/governance/Treasury.sol": {
      "content": "// 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); }
    }
}
"
    },
    "contracts/governance/VotingEscrow.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/IncludeAll.sol": {
      "content": "// 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 */
"
    },
    "contracts/interfaces/ICustom1.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom1 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom10.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom10 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom2.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom2 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom3.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom3 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom4.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom4 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom5.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom5 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom6.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom6 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom7.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom7 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom8.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom8 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/ICustom9.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ICustom9 { function x() external view returns (uint); }"
    },
    "contracts/interfaces/IERC20.sol": {
      "content": "// 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);
}
"
    },
    "contracts/interfaces/IMegaSwapCallee.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IMegaSwapCallee { function megaswapCall(address sender,uint amount0,uint amount1,bytes calldata data) external; }"
    },
    "contracts/interfaces/IMegaSwapFactory.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IMegaSwapFactory { function createPair(address, address) external returns(address); }"
    },
    "contracts/interfaces/IMegaSwapPair.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IMegaSwapPair { function getReserves() external view returns(uint112,uint112); }"
    },
    "contracts/interfaces/IMegaSwapRouter01.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IMegaSwapRouter01 { }"
    },
    "contracts/interfaces/IMegaSwapRouter02.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IMegaSwapRouter02 { }"
    },
    "contracts/interfaces/IWETH.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IWETH { function deposit() external payable; function withdraw(uint) external; }"
    },
    "contracts/libraries/MegaSwapLibrary.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/libraries/TransferHelper.sol": {
      "content": "// 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');
    }
}
"
    },
    "contracts/libraries/UQ112x112.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/migration/LiquidityMigrator.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract LiquidityMigrator { }"
    },
    "contracts/migration/Migration3.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Migration3 { }"
    },
    "contracts/migration/Migration4.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Migration4 { }"
    },
    "contracts/migration/Migration5.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Migration5 { }"
    },
    "contracts/migration/Migrator.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Migrator { }"
    },
    "contracts/mocks/Mock1.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock1 { function id() external pure returns (uint) { return 1; } }"
    },
    "contracts/mocks/Mock10.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock10 { function id() external pure returns (uint) { return 10; } }"
    },
    "contracts/mocks/Mock11.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock11 { function id() external pure returns (uint) { return 11; } }"
    },
    "contracts/mocks/Mock12.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock12 { function id() external pure returns (uint) { return 12; } }"
    },
    "contracts/mocks/Mock13.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock13 { function id() external pure returns (uint) { return 13; } }"
    },
    "contracts/mocks/Mock14.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock14 { function id() external pure returns (uint) { return 14; } }"
    },
    "contracts/mocks/Mock15.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock15 { function id() external pure returns (uint) { return 15; } }"
    },
    "contracts/mocks/Mock16.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock16 { function id() external pure returns (uint) { return 16; } }"
    },
    "contracts/mocks/Mock17.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock17 { function id() external pure returns (uint) { return 17; } }"
    },
    "contracts/mocks/Mock18.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock18 { function id() external pure returns (uint) { return 18; } }"
    },
    "contracts/mocks/Mock19.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock19 { function id() external pure returns (uint) { return 19; } }"
    },
    "contracts/mocks/Mock2.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock2 { function id() external pure returns (uint) { return 2; } }"
    },
    "contracts/mocks/Mock20.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock20 { function id() external pure returns (uint) { return 20; } }"
    },
    "contracts/mocks/Mock3.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock3 { function id() external pure returns (uint) { return 3; } }"
    },
    "contracts/mocks/Mock4.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock4 { function id() external pure returns (uint) { return 4; } }"
    },
    "contracts/mocks/Mock5.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock5 { function id() external pure returns (uint) { return 5; } }"
    },
    "contracts/mocks/Mock6.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock6 { function id() external pure returns (uint) { return 6; } }"
    },
    "contracts/mocks/Mock7.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock7 { function id() external pure returns (uint) { return 7; } }"
    },
    "contracts/mocks/Mock8.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock8 { function id() external pure returns (uint) { return 8; } }"
    },
    "contracts/mocks/Mock9.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Mock9 { function id() external pure returns (uint) { return 9; } }"
    },
    "contracts/oracle/ChainlinkPriceOracle.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract ChainlinkPriceOracle { address public feed; constructor(address _f){feed=_f;} }"
    },
    "contracts/oracle/Oracle10.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle10 { function peek() external pure returns(uint){ return 10; } }"
    },
    "contracts/oracle/Oracle4.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle4 { function peek() external pure returns(uint){ return 4; } }"
    },
    "contracts/oracle/Oracle5.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle5 { function peek() external pure returns(uint){ return 5; } }"
    },
    "contracts/oracle/Oracle6.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle6 { function peek() external pure returns(uint){ return 6; } }"
    },
    "contracts/oracle/Oracle7.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle7 { function peek() external pure returns(uint){ return 7; } }"
    },
    "contracts/oracle/Oracle8.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle8 { function peek() external pure returns(uint){ return 8; } }"
    },
    "contracts/oracle/Oracle9.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Oracle9 { function peek() external pure returns(uint){ return 9; } }"
    },
    "contracts/oracle/PriceOracle.sol": {
      "content": "// 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; }}"
    },
    "contracts/oracle/TWAPOracle.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract TWAPOracle { }"
    },
    "contracts/periphery/FlashLoan.sol": {
      "content": "// 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);
    }
}
"
    },
    "contracts/periphery/MegaSwapRouter01.sol": {
      "content": "// 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);
}
"
    },
    "contracts/periphery/MegaSwapRouter02.sol": {
      "content": "// 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);
}
"
    },
    "contracts/periphery/SwapHelper.sol": {
      "content": "// 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; }
}
"
    },
    "contracts/security/AccessControl.sol": {
      "content": "// 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); }
}
"
    },
    "contracts/security/Ownable.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/security/Pausable.sol": {
      "content": "// 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");
        _;
    }
}
"
    },
    "contracts/security/ReentrancyGuard.sol": {
      "content": "// 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;
    }
}
"
    },
    "contracts/tokens/MegaTokenV2Tax.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

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

/**
 * MegaTokenV2Tax (launch-ready)
 * - 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 <= 10%
 */
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 - 1000
    uint256 public sellTaxBps;      // 0 - 1000
    uint256 public transferTaxBps;  // 0 - 1000
    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);
        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 -----------------
    function _maxTxAmount() public view returns (uint256) {
        return (totalSupply * maxTxBps) / BPS_DENOM;
    }

    function _maxWalletAmount() public view returns (uint256) {
        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);
    }
}
"
    },
    "contracts/tokens/MegaUSD.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken1.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken10.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken11.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken12.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken13.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken14.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken15.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken2.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken3.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken4.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken5.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken6.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken7.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken8.sol": {
      "content": "// 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); } }
"
    },
    "contracts/tokens/TestToken9.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;


import "../core/MegaSwapERC20.sol";
contract TestToken9 is MegaSwa