{"AIOZToken.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \u0027./IERC20.sol\u0027;\nimport \u0027./IERC20Metadata.sol\u0027;\nimport \u0027./Ownable.sol\u0027;\nimport \u0027./TokenTimelock.sol\u0027;\n\ncontract ERC20 is IERC20, IERC20Metadata {\n    mapping (address =\u003e uint256) private _balances;\n\n    mapping (address =\u003e mapping (address =\u003e uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    constructor (string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n    \n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(msg.sender, recipient, amount);\n        return true;\n    }\n\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(msg.sender, spender, amount);\n        return true;\n    }\n\n    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n        uint256 currentAllowance = _allowances[sender][msg.sender];\n        require(currentAllowance \u003e= amount, \"ERC20: transfer amount exceeds allowance\");\n        _approve(sender, msg.sender, currentAllowance - amount);\n        return true;\n    }\n\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);\n        return true;\n    }\n\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        uint256 currentAllowance = _allowances[msg.sender][spender];\n        require(currentAllowance \u003e= subtractedValue, \"ERC20: decreased allowance below zero\");\n        _approve(msg.sender, spender, currentAllowance - subtractedValue);\n        return true;\n    }\n\n    function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        uint256 senderBalance = _balances[sender];\n        require(senderBalance \u003e= amount, \"ERC20: transfer amount exceeds balance\");\n        _balances[sender] = senderBalance - amount;\n        _balances[recipient] += amount;\n\n        emit Transfer(sender, recipient, amount);\n    }\n\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n    }\n\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance \u003e= amount, \"ERC20: burn amount exceeds balance\");\n        _balances[account] = accountBalance - amount;\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n    }\n\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n}\n\ncontract AIOZToken is ERC20, Ownable {\n    uint256 private _maxTotalSupply;\n    \n    constructor() ERC20(\"AIOZ Network\", \"AIOZ\") {\n        _maxTotalSupply = 1000000000e18;\n        \n        // init timelock factory\n        TimelockFactory timelockFactory = new TimelockFactory();\n\n        // ERC20\n        // public sales\n        mint(0x076592ad72b79bBaBDD05aDd7d367f44f2CFf658, 10333333e18); // for Paid Ignition\n        // private sales\n        mint(0xF8477220f8375968E38a3B79ECA4343822b53af2, 73000000e18*25/100);\n        address privateSalesLock = timelockFactory.createTimelock(this, 0xF8477220f8375968E38a3B79ECA4343822b53af2, block.timestamp + 30 days, 73000000e18*25/100, 30 days);\n        mint(privateSalesLock, 73000000e18*75/100);\n        // team\n        address teamLock = timelockFactory.createTimelock(this, 0x82E83054CC631C0Da85Ca67087E45ca31b93F29b, block.timestamp + 180 days, 250000000e18*8/100, 30 days);\n        mint(teamLock, 250000000e18);\n        // advisors\n        address advisorsLock = timelockFactory.createTimelock(this, 0xBbf78c2Ee1794229e31af81c83F4d5125F08FE0F, block.timestamp + 90 days, 50000000e18*8/100, 30 days);\n        mint(advisorsLock, 50000000e18);\n        // marketing\n        mint(0x9E2F8e278585CAfD3308E894d2E09ffEc520b1E9, 30000000e18*10/100);\n        address marketingERC20Lock = timelockFactory.createTimelock(this, 0x9E2F8e278585CAfD3308E894d2E09ffEc520b1E9, block.timestamp + 30 days, 30000000e18*5/100, 30 days);\n        mint(marketingERC20Lock, 30000000e18*90/100);\n        // exchange liquidity provision\n        mint(0x6c3D8872002B66C808aE462Db314B87962DCC7aF, 23333333e18);\n        // ecosystem growth\n        address growthLock = timelockFactory.createTimelock(this, 0xCFd6736a11e76c0e3418FEEbb788822211d92F1e, block.timestamp + 90 days, 0, 0);\n        mint(growthLock, 530000000e18);\n\n        // BEP20\n        // // public sales\n        // mint(0xc9Fc843DBAA8ccCcf37E09b67DeEa5f963E3919E, 6666667e18); // for BSCPad\n        // // marketing\n        // mint(0x7e318e80EB8e401451334cAa2278E39Da7F6C49B, 20000000e18*10/100);\n        // address marketingBEP20Lock = timelockFactory.createTimelock(this, 0x7e318e80EB8e401451334cAa2278E39Da7F6C49B, block.timestamp + 30 days, 20000000e18*5/100, 30 days);\n        // mint(marketingBEP20Lock, 20000000e18*90/100);\n        // // exchange liquidity provision\n        // mint(0x0a515Ac284E3c741575A4fd71C27e377a19D5E6D, 6666667e18);\n    }\n\n    function mint(address account, uint256 amount) public onlyOwner returns (bool) {\n        require(totalSupply() + amount \u003c= _maxTotalSupply, \"AIOZ Token: mint more than the max total supply\");\n        _mint(account, amount);\n        return true;\n    }\n\n    function burn(uint256 amount) public onlyOwner returns (bool) {\n        _burn(msg.sender, amount);\n        return true;\n    }\n}"},"IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    function totalSupply() external view returns (uint256);\n    function balanceOf(address account) external view returns (uint256);\n    function transfer(address recipient, uint256 amount) external returns (bool);\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 amount) external returns (bool);\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}"},"IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\n\ninterface IERC20Metadata is IERC20 {\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function decimals() external view returns (uint8);\n}"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor () {\n        address msgSender = msg.sender;\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == msg.sender, \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        emit OwnershipTransferred(_owner, address(0));\n        _owner = address(0);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n}"},"TokenTimelock.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \u0027./IERC20.sol\u0027;\n\ncontract TokenTimelock {\n    IERC20 private _token;\n    address private _beneficiary;\n    uint256 private _nextReleaseTime;\n    uint256 private _releaseAmount;\n    uint256 private _releasePeriod;\n\n    TimelockFactory private _factory;\n\n    event Released(address indexed beneficiary, uint256 amount);\n    event BeneficiaryTransferred(address indexed previousBeneficiary, address indexed newBeneficiary);\n\n\tconstructor(){\n\t\t_token = IERC20(address(1));\n\t}\n\n\tfunction init(IERC20 token_, address beneficiary_, uint256 releaseStart_, uint256 releaseAmount_, uint256 releasePeriod_) external {\n\t\trequire(_token == IERC20(address(0)), \"TokenTimelock: already initialized\");\n\t\trequire(token_ != IERC20(address(0)), \"TokenTimelock: erc20 token address is zero\");\n        require(beneficiary_ != address(0), \"TokenTimelock: beneficiary address is zero\");\n        require(releasePeriod_ == 0 || releaseAmount_ != 0, \"TokenTimelock: release amount is zero\");\n\n        emit BeneficiaryTransferred(address(0), beneficiary_);\n\n        _token = token_;\n        _beneficiary = beneficiary_;\n        _nextReleaseTime = releaseStart_;\n        _releaseAmount = releaseAmount_;\n        _releasePeriod = releasePeriod_;\n\n        _factory = TimelockFactory(msg.sender);\n\t}\n\n    function token() public view virtual returns (IERC20) {\n        return _token;\n    }\n\n    function beneficiary() public view virtual returns (address) {\n        return _beneficiary;\n    }\n\n    function nextReleaseTime() public view virtual returns (uint256) {\n        return _nextReleaseTime;\n    }\n\n    function releaseAmount() public view virtual returns (uint256) {\n        return _releaseAmount;\n    }\n\n    function balance() public view virtual returns (uint256) {\n        return token().balanceOf(address(this));\n    }\n\n    function releasableAmount() public view virtual returns (uint256) {\n        if (block.timestamp \u003c _nextReleaseTime) return 0;\n\n        uint256 amount = balance();\n        if (amount == 0) return 0;\n        if (_releasePeriod == 0) return amount;\n\n        uint256 passedPeriods = (block.timestamp - _nextReleaseTime) / _releasePeriod;\n        uint256 maxReleasableAmount = (passedPeriods + 1) * _releaseAmount;\n        \n        if (amount \u003c= maxReleasableAmount) return amount;\n        return maxReleasableAmount;\n    }\n\n    function releasePeriod() public view virtual returns (uint256) {\n        return _releasePeriod;\n    }\n\n    function release() public virtual returns (bool) {\n        // solhint-disable-next-line not-rely-on-time\n        require(block.timestamp \u003e= nextReleaseTime(), \"TokenTimelock: current time is before release time\");\n\n        uint256 _releasableAmount = releasableAmount();\n        require(_releasableAmount \u003e 0, \"TokenTimelock: no releasable tokens\");\n\n        emit Released(beneficiary(), _releasableAmount);\n        require(token().transfer(beneficiary(), _releasableAmount));\n\n        if (_releasePeriod != 0) {\n            uint256 passedPeriods = (block.timestamp - _nextReleaseTime) / _releasePeriod;\n            _nextReleaseTime += (passedPeriods + 1) * _releasePeriod;\n        }\n\n        return true;\n    }\n\n    function transferBeneficiary(address newBeneficiary) public virtual returns (bool) {\n\t\trequire(msg.sender == beneficiary(), \"TokenTimelock: caller is not the beneficiary\");\n\t\trequire(newBeneficiary != address(0), \"TokenTimelock: the new beneficiary is zero address\");\n\t\t\n        emit BeneficiaryTransferred(beneficiary(), newBeneficiary);\n\t\t_beneficiary = newBeneficiary;\n\t\treturn true;\n\t}\n\n    function split(address splitBeneficiary, uint256 splitAmount) public virtual returns (bool) {\n        uint256 _amount = balance();\n\t\trequire(msg.sender == beneficiary(), \"TokenTimelock: caller is not the beneficiary\");\n\t\trequire(splitBeneficiary != address(0), \"TokenTimelock: beneficiary address is zero\");\n        require(splitAmount \u003e 0, \"TokenTimelock: amount is zero\");\n        require(splitAmount \u003c= _amount, \"TokenTimelock: amount exceeds balance\");\n\n        uint256 splitReleaseAmount;\n        if (_releasePeriod \u003e 0) {\n            splitReleaseAmount = _releaseAmount * splitAmount / _amount;\n        }\n\n        address newTimelock = _factory.createTimelock(token(), splitBeneficiary, _nextReleaseTime, splitReleaseAmount, _releasePeriod);\n\n        require(token().transfer(newTimelock, splitAmount));\n        _releaseAmount -= splitReleaseAmount;\n\t\treturn true;\n\t}\n}\n\ncontract CloneFactory {\n  function createClone(address target) internal returns (address result) {\n    bytes20 targetBytes = bytes20(target);\n    assembly {\n      let clone := mload(0x40)\n      mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n      mstore(add(clone, 0x14), targetBytes)\n      mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n      result := create(0, clone, 0x37)\n    }\n  }\n}\n\ncontract TimelockFactory is CloneFactory {\n\taddress private _tokenTimelockImpl;\n\tevent Timelock(address timelockContract);\n\tconstructor() {\n\t\t_tokenTimelockImpl = address(new TokenTimelock());\n\t}\n\tfunction createTimelock(IERC20 token, address to, uint256 releaseTime, uint256 releaseAmount, uint256 period) public returns (address) {\n\t\taddress clone = createClone(_tokenTimelockImpl);\n\t\tTokenTimelock(clone).init(token, to, releaseTime, releaseAmount, period);\n\n\t\temit Timelock(clone);\n\t\treturn clone;\n\t}\n}"}}