1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
interface IZeroEx {
    function getFunctionImplementation(bytes4 _signature) external returns (address);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "./IZeroEx.sol";
import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
import "@0x/contracts-zero-ex/contracts/src/errors/LibProxyRichErrors.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title Coinbase proxy contract for 0x proxy
/// @dev A generic proxy contract which extracts a fee before delegation
contract ZeroExProxy is Ownable {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
{"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}"}}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
  Copyright 2020 ZeroEx Intl.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/
pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;
import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
import "./migrations/LibBootstrap.sol";
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX