Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import "StorageStateCommittee.sol";
//import "Ownable.sol";
import "AccessControl.sol";
import { ERC165 } from "ERC165.sol";

contract DAOCommitteeProxy is StorageStateCommittee, AccessControl, ERC165 {
    address internal _implementation;
    bool public pauseProxy;

    event Upgraded(address indexed implementation);

    modifier onlyOwner() {
        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "DAOCommitteeProxy: msg.sender is not an admin");
        _;
    }
     
    constructor(
        address _ton,
        address _impl,
        address _seigManager,
        address _layer2Registry,
        address _agendaManager,
        address _candidateFactory,
        //address _activityRewardManager,
        address _daoVault
    )
    {
        require(
            _ton != address(0)
            || _impl != address(0)
            || _seigManager != address(0)
            || _layer2Registry != address(0)
            || _agendaManager != address(0)
            || _candidateFactory != address(0),
            "DAOCommitteeProxy: input is zero"
        );
        ton = _ton;
        _implementation = _impl;
        seigManager = ISeigManager(_seigManager);
        layer2Registry = ILayer2Registry(_layer2Registry);
        agendaManager = IDAOAgendaManager(_agendaManager);
        candidateFactory = ICandidateFactory(_candidateFactory);
        daoVault = IDAOVault(_daoVault);
        quorum = 2;
        activityRewardPerSecond = 3170979198376458;

        _registerInterface(bytes4(keccak256("onApprove(address,address,uint256,bytes)")));
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(DEFAULT_ADMIN_ROLE, address(this));
    }

    /// @notice Set pause state
    /// @param _pause true:pause or false:resume
    function setProxyPause(bool _pause) external onlyOwner {
        pauseProxy = _pause;
    }

    /// @notice Set implementation contract
    /// @param impl New implementation contract address
    function upgradeTo(address impl) external onlyOwner {
        require(_implementation != address(0), "DAOCommitteeProxy: input is zero");
        require(_implementation != impl, "DAOCommitteeProxy: The input address is same as the state");
        _implementation = impl;
        emit Upgraded(impl);
    }

    function implementation() public view returns (address) {
        return _implementation;
    }

    fallback() external {
        _fallback();
    }

    function _fallback() internal {
        address _impl = implementation();
        require(_impl != address(0) && !pauseProxy, "DAOCommitteeProxy: impl is zero OR proxy is false");

        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), _impl, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "EnumerableSet.sol";
import "Address.sol";
import "Context.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
        return _roles[role].members.at(index);
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import { IStorageStateCommittee } from "IStorageStateCommittee.sol";
import { ICandidateFactory } from "ICandidateFactory.sol";
import { ILayer2Registry } from "ILayer2Registry.sol";
import { ISeigManager } from "ISeigManager.sol";
import { IDAOAgendaManager } from "IDAOAgendaManager.sol";
import { IDAOVault } from "IDAOVault.sol";
import { ICandidate } from "ICandidate.sol";

contract StorageStateCommittee is IStorageStateCommittee {
    enum AgendaStatus { NONE, NOTICE, VOTING, EXEC, ENDED, PENDING, RISK }
    enum AgendaResult { UNDEFINED, ACCEPT, REJECT, DISMISS }

    address public override ton;
    IDAOVault public override daoVault;
    IDAOAgendaManager public override agendaManager;
    ICandidateFactory public override candidateFactory;
    ILayer2Registry public override layer2Registry;
    ISeigManager public override seigManager;

    address[] public override candidates;
    address[] public override members;
    uint256 public override maxMember;

    // candidate EOA => candidate information
    mapping(address => CandidateInfo) internal _candidateInfos;
    uint256 public override quorum;

    uint256 public override activityRewardPerSecond;

    modifier validAgendaManager() {
        require(address(agendaManager) != address(0), "StorageStateCommittee: AgendaManager is zero");
        _;
    }
    
    modifier validCommitteeL2Factory() {
        require(address(candidateFactory) != address(0), "StorageStateCommittee: invalid CommitteeL2Factory");
        _;
    }

    modifier validLayer2Registry() {
        require(address(layer2Registry) != address(0), "StorageStateCommittee: invalid Layer2Registry");
        _;
    }

    modifier validSeigManager() {
        require(address(seigManager) != address(0), "StorageStateCommittee: invalid SeigManagere");
        _;
    }

    modifier onlyMember() {
        require(isMember(msg.sender), "StorageStateCommittee: not a member");
        _;
    }

    modifier onlyMemberContract() {
        address candidate = ICandidate(msg.sender).candidate();
        require(isMember(candidate), "StorageStateCommittee: not a member");
        _;
    }
    
    function isMember(address _candidate) public view override returns (bool) {
        return _candidateInfos[_candidate].memberJoinedTime > 0;
    }

    function candidateContract(address _candidate) public view override returns (address) {
        return _candidateInfos[_candidate].candidateContract;
    }

    function candidateInfos(address _candidate) external override returns (CandidateInfo memory) {
        return _candidateInfos[_candidate];
    }

    /*function getCandidate() public view returns (address) {
        ILayer2(_candidateContract).
    }*/
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

import { IDAOCommittee } from "IDAOCommittee.sol";
import { ISeigManager } from "ISeigManager.sol";

interface ICandidate {
    function setSeigManager(address _seigMan) external;
    function setCommittee(address _committee) external;
    function updateSeigniorage() external returns (bool);
    function changeMember(uint256 _memberIndex) external returns (bool);
    function retireMember() external returns (bool);
    function castVote(uint256 _agendaID, uint256 _vote, string calldata _comment) external;
    function isCandidateContract() external view returns (bool);
    function totalStaked() external view returns (uint256 totalsupply);
    function stakedOf(address _account) external view returns (uint256 amount);
    function setMemo(string calldata _memo) external;
    function claimActivityReward() external;

    // getter
    function candidate() external view returns (address);
    function isLayer2Candidate() external view returns (bool);
    function memo() external view returns (string memory);
    function committee() external view returns (IDAOCommittee);
    function seigManager() external view returns (ISeigManager);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import { LibAgenda } from "LibAgenda.sol";
import { IDAOCommittee } from "IDAOCommittee.sol";

interface IDAOAgendaManager  {
    struct Ratio {
        uint256 numerator;
        uint256 denominator;
    }

    function setCommittee(address _committee) external;
    function setCreateAgendaFees(uint256 _createAgendaFees) external;
    function setMinimumNoticePeriodSeconds(uint256 _minimumNoticePeriodSeconds) external;
    function setMinimumVotingPeriodSeconds(uint256 _minimumVotingPeriodSeconds) external;
    function setExecutingPeriodSeconds(uint256 _executingPeriodSeconds) external;
    function newAgenda(
        address[] memory _targets,
        uint256 _noticePeriodSeconds,
        uint256 _votingPeriodSeconds,
        bool _atomicExecute,
        bytes[] calldata _functionBytecodes
    )
        external
        returns (uint256 agendaID);
    function castVote(uint256 _agendaID, address voter, uint256 _vote) external returns (bool);
    function setExecutedAgenda(uint256 _agendaID) external;
    function setResult(uint256 _agendaID, LibAgenda.AgendaResult _result) external;
    function setStatus(uint256 _agendaID, LibAgenda.AgendaStatus _status) external;
    function endAgendaVoting(uint256 _agendaID) external;
    function setExecutedCount(uint256 _agendaID, uint256 _count) external;
     
    // -- view functions
    function isVoter(uint256 _agendaID, address _user) external view returns (bool);
    function hasVoted(uint256 _agendaID, address _user) external view returns (bool);
    function getVoteStatus(uint256 _agendaID, address _user) external view returns (bool, uint256);
    function getAgendaNoticeEndTimeSeconds(uint256 _agendaID) external view returns (uint256);
    function getAgendaVotingStartTimeSeconds(uint256 _agendaID) external view returns (uint256);
    function getAgendaVotingEndTimeSeconds(uint256 _agendaID) external view returns (uint256) ;

    function canExecuteAgenda(uint256 _agendaID) external view returns (bool);
    function getAgendaStatus(uint256 _agendaID) external view returns (uint256 status);
    function totalAgendas() external view returns (uint256);
    function getAgendaResult(uint256 _agendaID) external view returns (uint256 result, bool executed);
    function getExecutionInfo(uint256 _agendaID)
        external
        view
        returns(
            address[] memory target,
            bytes[] memory functionBytecode,
            bool atomicExecute,
            uint256 executeStartFrom
        );
    function isVotableStatus(uint256 _agendaID) external view returns (bool);
    function getVotingCount(uint256 _agendaID)
        external
        view
        returns (
            uint256 countingYes,
            uint256 countingNo,
            uint256 countingAbstain
        );
    function getAgendaTimestamps(uint256 _agendaID)
        external
        view
        returns (
            uint256 createdTimestamp,
            uint256 noticeEndTimestamp,
            uint256 votingStartedTimestamp,
            uint256 votingEndTimestamp,
            uint256 executedTimestamp
        );
    function numAgendas() external view returns (uint256);
    function getVoters(uint256 _agendaID) external view returns (address[] memory);

    function getStatus(uint256 _createAgendaFees) external pure returns (LibAgenda.AgendaStatus);

    // getter
    function committee() external view returns (IDAOCommittee);
    function createAgendaFees() external view returns (uint256);
    function minimumNoticePeriodSeconds() external view returns (uint256);
    function minimumVotingPeriodSeconds() external view returns (uint256);
    function executingPeriodSeconds() external view returns (uint256);
    function agendas(uint256 _index) external view returns (LibAgenda.Agenda memory);
    function voterInfos(uint256 _index1, address _index2) external view returns (LibAgenda.Voter memory);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

library LibAgenda {
    //using LibAgenda for Agenda;

    enum AgendaStatus { NONE, NOTICE, VOTING, WAITING_EXEC, EXECUTED, ENDED }
    enum AgendaResult { PENDING, ACCEPT, REJECT, DISMISS }

    //votor : based operator 
    struct Voter {
        bool isVoter;
        bool hasVoted;
        uint256 vote;
    }

    // counting abstainVotes yesVotes noVotes
    struct Agenda {
        uint256 createdTimestamp;
        uint256 noticeEndTimestamp;
        uint256 votingPeriodInSeconds;
        uint256 votingStartedTimestamp;
        uint256 votingEndTimestamp;
        uint256 executableLimitTimestamp;
        uint256 executedTimestamp;
        uint256 countingYes;
        uint256 countingNo;
        uint256 countingAbstain;
        AgendaStatus status;
        AgendaResult result;
        address[] voters;
        bool executed;
    }

    struct AgendaExecutionInfo {
        address[] targets;
        bytes[] functionBytecodes;
        bool atomicExecute;
        uint256 executeStartFrom;
    }

    /*function getAgenda(Agenda[] storage agendas, uint256 index) public view returns (Agenda storage agenda) {
        return agendas[index];
    }*/
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Library used to query support of an interface declared via {IERC165}.
 *
 * Note that these functions return the actual result of the query: they do not
 * `revert` if an interface is not supported. It is up to the caller to decide
 * what to do in these cases.
 */
library ERC165Checker {
    // As per the EIP-165 spec, no interface should ever match 0xffffffff
    bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;

    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Returns true if `account` supports the {IERC165} interface,
     */
    function supportsERC165(address account) internal view returns (bool) {
        // Any contract that implements ERC165 must explicitly indicate support of
        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
        return _supportsERC165Interface(account, _INTERFACE_ID_ERC165) &&
            !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);
    }

    /**
     * @dev Returns true if `account` supports the interface defined by
     * `interfaceId`. Support for {IERC165} itself is queried automatically.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
        // query support of both ERC165 as per the spec and support of _interfaceId
        return supportsERC165(account) &&
            _supportsERC165Interface(account, interfaceId);
    }

    /**
     * @dev Returns true if `account` supports all the interfaces defined in
     * `interfaceIds`. Support for {IERC165} itself is queried automatically.
     *
     * Batch-querying can lead to gas savings by skipping repeated checks for
     * {IERC165} support.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
        // query support of ERC165 itself
        if (!supportsERC165(account)) {
            return false;
        }

        // query support of each interface in _interfaceIds
        for (uint256 i = 0; i < interfaceIds.length; i++) {
            if (!_supportsERC165Interface(account, interfaceIds[i])) {
                return false;
            }
        }

        // all interfaces supported
        return true;
    }

    /**
     * @notice Query if a contract implements an interface, does not check ERC165 support
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return true if the contract at account indicates support of the interface with
     * identifier interfaceId, false otherwise
     * @dev Assumes that account contains a contract that supports ERC165, otherwise
     * the behavior of this method is undefined. This precondition can be checked
     * with {supportsERC165}.
     * Interface identification is specified in ERC-165.
     */
    function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {
        // success determines whether the staticcall succeeded and result determines
        // whether the contract at account indicates support of _interfaceId
        (bool success, bool result) = _callERC165SupportsInterface(account, interfaceId);

        return (success && result);
    }

    /**
     * @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return success true if the STATICCALL succeeded, false otherwise
     * @return result true if the STATICCALL succeeded and the contract at account
     * indicates support of the interface with identifier interfaceId, false otherwise
     */
    function _callERC165SupportsInterface(address account, bytes4 interfaceId)
        private
        view
        returns (bool, bool)
    {
        bytes memory encodedParams = abi.encodeWithSelector(_INTERFACE_ID_ERC165, interfaceId);
        (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);
        if (result.length < 32) return (false, false);
        return (success, abi.decode(result, (bool)));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import { SafeMath } from "SafeMath.sol";
import { IERC20 } from  "IERC20.sol";
import { IDAOAgendaManager } from "IDAOAgendaManager.sol";
import { IDAOCommittee } from "IDAOCommittee.sol";
import { ICandidate } from "ICandidate.sol";
import { LibAgenda } from "LibAgenda.sol";
import "Ownable.sol";

contract DAOAgendaManager is Ownable, IDAOAgendaManager {
    using SafeMath for uint256;
    using LibAgenda for *;

    enum VoteChoice { ABSTAIN, YES, NO, MAX }

    IDAOCommittee public override committee;
    
    uint256 public override createAgendaFees; // 아젠다생성비용(TON)
    
    uint256 public override minimumNoticePeriodSeconds;
    uint256 public override minimumVotingPeriodSeconds;
    uint256 public override executingPeriodSeconds;
    
    LibAgenda.Agenda[] internal _agendas;
    mapping(uint256 => mapping(address => LibAgenda.Voter)) internal _voterInfos;
    mapping(uint256 => LibAgenda.AgendaExecutionInfo) internal _executionInfos;
    
    event AgendaStatusChanged(
        uint256 indexed agendaID,
        uint256 prevStatus,
        uint256 newStatus
    );

    event AgendaResultChanged(
        uint256 indexed agendaID,
        uint256 result
    );

    event CreatingAgendaFeeChanged(
        uint256 newFee
    );

    event MinimumNoticePeriodChanged(
        uint256 newPeriod
    );

    event MinimumVotingPeriodChanged(
        uint256 newPeriod
    );

    event ExecutingPeriodChanged(
        uint256 newPeriod
    );

    modifier validAgenda(uint256 _agendaID) {
        require(_agendaID < _agendas.length, "DAOAgendaManager: invalid agenda id");
        _;
    }
    
    constructor() {
        /*minimumNoticePeriodSeconds = 16 days;
        minimumVotingPeriodSeconds = 2 days;
        executingPeriodSeconds = 7 days;*/
        minimumNoticePeriodSeconds = 300;
        minimumVotingPeriodSeconds = 300;
        executingPeriodSeconds = 300;
        
        createAgendaFees = 100000000000000000000; // 100 TON
    }

    function getStatus(uint256 _status) public pure override returns (LibAgenda.AgendaStatus emnustatus) {
        require(_status < 6, "DAOAgendaManager: invalid status value");
        if (_status == uint256(LibAgenda.AgendaStatus.NOTICE))
            return LibAgenda.AgendaStatus.NOTICE;
        else if (_status == uint256(LibAgenda.AgendaStatus.VOTING))
            return LibAgenda.AgendaStatus.VOTING;
        else if (_status == uint256(LibAgenda.AgendaStatus.EXECUTED))
            return LibAgenda.AgendaStatus.EXECUTED;
        else if (_status == uint256(LibAgenda.AgendaStatus.ENDED))
            return LibAgenda.AgendaStatus.ENDED;
        else
            return LibAgenda.AgendaStatus.NONE;
    }

    /// @notice Set DAOCommitteeProxy contract address
    /// @param _committee New DAOCommitteeProxy contract address
    function setCommittee(address _committee) external override onlyOwner {
        require(_committee != address(0), "DAOAgendaManager: address is zero");
        committee = IDAOCommittee(_committee);
    }

    /// @notice Set status of the agenda
    /// @param _agendaID agenda ID
    /// @param _status New status of the agenda
    /*function setStatus(uint256 _agendaID, uint256 _status) public override onlyOwner {
        require(_agendaID < _agendas.length, "DAOAgendaManager: Not a valid Proposal Id");

        emit AgendaStatusChanged(_agendaID, uint256(_agendas[_agendaID].status), _status);
        _agendas[_agendaID].status = getStatus(_status);
    }*/

    /// @notice Set the fee(TON) of creating an agenda
    /// @param _createAgendaFees New fee(TON)
    function setCreateAgendaFees(uint256 _createAgendaFees) external override onlyOwner {
        createAgendaFees = _createAgendaFees;
        emit CreatingAgendaFeeChanged(_createAgendaFees);
    }

    /// @notice Set the minimum notice period in seconds
    /// @param _minimumNoticePeriodSeconds New minimum notice period in seconds
    function setMinimumNoticePeriodSeconds(uint256 _minimumNoticePeriodSeconds) external override onlyOwner {
        minimumNoticePeriodSeconds = _minimumNoticePeriodSeconds;
        emit MinimumNoticePeriodChanged(_minimumNoticePeriodSeconds);
    }

    /// @notice Set the executing period in seconds
    /// @param _executingPeriodSeconds New executing period in seconds
    function setExecutingPeriodSeconds(uint256 _executingPeriodSeconds) external override onlyOwner {
        executingPeriodSeconds = _executingPeriodSeconds;
        emit ExecutingPeriodChanged(_executingPeriodSeconds);
    }

    /// @notice Set the minimum voting period in seconds
    /// @param _minimumVotingPeriodSeconds New minimum voting period in seconds
    function setMinimumVotingPeriodSeconds(uint256 _minimumVotingPeriodSeconds) external override onlyOwner {
        minimumVotingPeriodSeconds = _minimumVotingPeriodSeconds;
        emit MinimumVotingPeriodChanged(_minimumVotingPeriodSeconds);
    }
      
    /// @notice Creates an agenda
    /// @param _targets Target addresses for executions of the agenda
    /// @param _noticePeriodSeconds Notice period in seconds
    /// @param _votingPeriodSeconds Voting period in seconds
    /// @param _functionBytecodes RLP-Encoded parameters for executions of the agenda
    /// @return agendaID Created agenda ID
    function newAgenda(
        address[] calldata _targets,
        uint256 _noticePeriodSeconds,
        uint256 _votingPeriodSeconds,
        bool _atomicExecute,
        bytes[] calldata _functionBytecodes
    )
        external
        override
        onlyOwner
        returns (uint256 agendaID)
    {
        require(
            _noticePeriodSeconds >= minimumNoticePeriodSeconds,
            "DAOAgendaManager: minimumNoticePeriod is short"
        );

        agendaID = _agendas.length;
         
        address[] memory emptyArray;
        _agendas.push(LibAgenda.Agenda({
            status: LibAgenda.AgendaStatus.NOTICE,
            result: LibAgenda.AgendaResult.PENDING,
            executed: false,
            createdTimestamp: block.timestamp,
            noticeEndTimestamp: block.timestamp + _noticePeriodSeconds,
            votingPeriodInSeconds: _votingPeriodSeconds,
            votingStartedTimestamp: 0,
            votingEndTimestamp: 0,
            executableLimitTimestamp: 0,
            executedTimestamp: 0,
            countingYes: 0,
            countingNo: 0,
            countingAbstain: 0,
            voters: emptyArray
        }));

        LibAgenda.AgendaExecutionInfo storage executionInfo = _executionInfos[agendaID];
        executionInfo.atomicExecute = _atomicExecute;
        executionInfo.executeStartFrom = 0;
        for (uint256 i = 0; i < _targets.length; i++) {
            executionInfo.targets.push(_targets[i]);
            executionInfo.functionBytecodes.push(_functionBytecodes[i]);
        }
    }

    /// @notice Casts vote for an agenda
    /// @param _agendaID Agenda ID
    /// @param _voter Voter
    /// @param _vote Voting type
    /// @return Whether or not the execution succeeded
    function castVote(
        uint256 _agendaID,
        address _voter,
        uint256 _vote
    )
        external
        override
        onlyOwner
        validAgenda(_agendaID)
        returns (bool)
    {
        require(_vote < uint256(VoteChoice.MAX), "DAOAgendaManager: invalid vote");

        require(
            isVotableStatus(_agendaID),
            "DAOAgendaManager: invalid status"
        );

        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        if (agenda.status == LibAgenda.AgendaStatus.NOTICE) {
            _startVoting(_agendaID);
        }

        require(isVoter(_agendaID, _voter), "DAOAgendaManager: not a voter");
        require(!hasVoted(_agendaID, _voter), "DAOAgendaManager: already voted");

        require(
            block.timestamp <= agenda.votingEndTimestamp,
            "DAOAgendaManager: for this agenda, the voting time expired"
        );
        
        LibAgenda.Voter storage voter = _voterInfos[_agendaID][_voter];
        voter.hasVoted = true;
        voter.vote = _vote;
             
        // counting 0:abstainVotes 1:yesVotes 2:noVotes
        if (_vote == uint256(VoteChoice.ABSTAIN))
            agenda.countingAbstain = agenda.countingAbstain.add(1);
        else if (_vote == uint256(VoteChoice.YES))
            agenda.countingYes = agenda.countingYes.add(1);
        else if (_vote == uint256(VoteChoice.NO))
            agenda.countingNo = agenda.countingNo.add(1);
        else
            revert("DAOAgendaManager: invalid voting");
        
        return true;
    }
    
    /// @notice Set the agenda status as executed
    /// @param _agendaID Agenda ID
    function setExecutedAgenda(uint256 _agendaID)
        external
        override
        onlyOwner
        validAgenda(_agendaID)
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];
        agenda.executed = true;
        agenda.executedTimestamp = block.timestamp;

        uint256 prevStatus = uint256(agenda.status);
        agenda.status = LibAgenda.AgendaStatus.EXECUTED;
        emit AgendaStatusChanged(_agendaID, prevStatus, uint256(LibAgenda.AgendaStatus.EXECUTED));
    }

    /// @notice Set the agenda result
    /// @param _agendaID Agenda ID
    /// @param _result New result
    function setResult(uint256 _agendaID, LibAgenda.AgendaResult _result)
        public
        override
        onlyOwner
        validAgenda(_agendaID)
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];
        agenda.result = _result;

        emit AgendaResultChanged(_agendaID, uint256(_result));
    }
     
    /// @notice Set the agenda status
    /// @param _agendaID Agenda ID
    /// @param _status New status
    function setStatus(uint256 _agendaID, LibAgenda.AgendaStatus _status)
        public
        override
        onlyOwner
        validAgenda(_agendaID)
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        uint256 prevStatus = uint256(agenda.status);
        agenda.status = _status;
        emit AgendaStatusChanged(_agendaID, prevStatus, uint256(_status));
    }

    /// @notice Set the agenda status as ended(denied or dismissed)
    /// @param _agendaID Agenda ID
    function endAgendaVoting(uint256 _agendaID)
        external
        override
        onlyOwner
        validAgenda(_agendaID)
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        require(
            agenda.status == LibAgenda.AgendaStatus.VOTING,
            "DAOAgendaManager: agenda status is not changable"
        );

        require(
            agenda.votingEndTimestamp <= block.timestamp,
            "DAOAgendaManager: voting is not ended yet"
        );

        setStatus(_agendaID, LibAgenda.AgendaStatus.ENDED);
        setResult(_agendaID, LibAgenda.AgendaResult.DISMISS);
    }
     
    function _startVoting(uint256 _agendaID) internal validAgenda(_agendaID) {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        agenda.votingStartedTimestamp = block.timestamp;
        agenda.votingEndTimestamp = block.timestamp.add(agenda.votingPeriodInSeconds);
        agenda.executableLimitTimestamp = agenda.votingEndTimestamp.add(executingPeriodSeconds);
        agenda.status = LibAgenda.AgendaStatus.VOTING;

        uint256 memberCount = committee.maxMember();
        for (uint256 i = 0; i < memberCount; i++) {
            address voter = committee.members(i);
            agenda.voters.push(voter);
            _voterInfos[_agendaID][voter].isVoter = true;
        }

        emit AgendaStatusChanged(_agendaID, uint256(LibAgenda.AgendaStatus.NOTICE), uint256(LibAgenda.AgendaStatus.VOTING));
    }
    
    function isVoter(uint256 _agendaID, address _candidate) public view override validAgenda(_agendaID) returns (bool) {
        require(_candidate != address(0), "DAOAgendaManager: user address is zero");
        return _voterInfos[_agendaID][_candidate].isVoter;
    }
    
    function hasVoted(uint256 _agendaID, address _user) public view override validAgenda(_agendaID) returns (bool) {
        return _voterInfos[_agendaID][_user].hasVoted;
    }

    function getVoteStatus(uint256 _agendaID, address _user) external view override validAgenda(_agendaID) returns (bool, uint256) {
        LibAgenda.Voter storage voter = _voterInfos[_agendaID][_user];

        return (
            voter.hasVoted,
            voter.vote
        );
    }
    
    function getAgendaNoticeEndTimeSeconds(uint256 _agendaID) external view override validAgenda(_agendaID) returns (uint256) {
        return _agendas[_agendaID].noticeEndTimestamp;
    }
    
    function getAgendaVotingStartTimeSeconds(uint256 _agendaID) external view override validAgenda(_agendaID) returns (uint256) {
        return _agendas[_agendaID].votingStartedTimestamp;
    }

    function getAgendaVotingEndTimeSeconds(uint256 _agendaID) external view override validAgenda(_agendaID) returns (uint256) {
        return _agendas[_agendaID].votingEndTimestamp;
    }

    function canExecuteAgenda(uint256 _agendaID) external view override validAgenda(_agendaID) returns (bool) {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        return agenda.status == LibAgenda.AgendaStatus.WAITING_EXEC &&
            block.timestamp <= agenda.executableLimitTimestamp &&
            agenda.result == LibAgenda.AgendaResult.ACCEPT &&
            agenda.votingEndTimestamp <= block.timestamp &&
            agenda.executed == false;
    }
    
    function getAgendaStatus(uint256 _agendaID) external view override validAgenda(_agendaID) returns (uint256 status) {
        return uint256(_agendas[_agendaID].status);
    }

    function totalAgendas() external view override returns (uint256) {
        return _agendas.length;
    }

    function getAgendaResult(uint256 _agendaID) external view override validAgenda(_agendaID) returns (uint256 result, bool executed) {
        return (uint256(_agendas[_agendaID].result), _agendas[_agendaID].executed);
    }
   
    function getExecutionInfo(uint256 _agendaID)
        external
        view
        override
        validAgenda(_agendaID)
        returns(
            address[] memory target,
            bytes[] memory functionBytecode,
            bool atomicExecute,
            uint256 executeStartFrom
        )
    {
        LibAgenda.AgendaExecutionInfo storage agenda = _executionInfos[_agendaID];
        return (
            agenda.targets,
            agenda.functionBytecodes,
            agenda.atomicExecute,
            agenda.executeStartFrom
        );
    }

    function setExecutedCount(uint256 _agendaID, uint256 _count) external override {
        LibAgenda.AgendaExecutionInfo storage agenda = _executionInfos[_agendaID];
        agenda.executeStartFrom = agenda.executeStartFrom.add(_count);
    }

    function isVotableStatus(uint256 _agendaID) public view override validAgenda(_agendaID) returns (bool) {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];

        return block.timestamp <= agenda.votingEndTimestamp ||
            (agenda.status == LibAgenda.AgendaStatus.NOTICE &&
                agenda.noticeEndTimestamp <= block.timestamp);
    }

    function getVotingCount(uint256 _agendaID)
        external
        view
        override
        returns (
            uint256 countingYes,
            uint256 countingNo,
            uint256 countingAbstain
        )
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];
        return (
            agenda.countingYes,
            agenda.countingNo,
            agenda.countingAbstain
        );
    }

    function getAgendaTimestamps(uint256 _agendaID)
        external
        view
        override
        validAgenda(_agendaID)
        returns (
            uint256 createdTimestamp,
            uint256 noticeEndTimestamp,
            uint256 votingStartedTimestamp,
            uint256 votingEndTimestamp,
            uint256 executedTimestamp
        )
    {
        LibAgenda.Agenda storage agenda = _agendas[_agendaID];
        return (
            agenda.createdTimestamp,
            agenda.noticeEndTimestamp,
            agenda.votingStartedTimestamp,
            agenda.votingEndTimestamp,
            agenda.executedTimestamp
        );
    }

    function numAgendas() external view override returns (uint256) {
        return _agendas.length;
    }

    function getVoters(uint256 _agendaID) external view override validAgenda(_agendaID) returns (address[] memory) {
        return _agendas[_agendaID].voters;
    }

    function agendas(uint256 _index) external view override validAgenda(_index) returns (LibAgenda.Agenda memory) {
        return _agendas[_index];
    }

    function voterInfos(uint256 _agendaID, address _voter) external view override validAgenda(_agendaID) returns (LibAgenda.Voter memory) {
        return _voterInfos[_agendaID][_voter];
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface ICandidateFactory {
    function deploy(
        address _candidate,
        bool _isLayer2Candidate,
        string memory _name,
        address _committee,
        address _seigManager
    )
        external
        returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface ILayer2Registry {
    function layer2s(address layer2) external view returns (bool);

    function register(address layer2) external returns (bool);
    function numLayer2s() external view returns (uint256);
    function layer2ByIndex(uint256 index) external view returns (address);

    function deployCoinage(address layer2, address seigManager) external returns (bool);
    function registerAndDeployCoinage(address layer2, address seigManager) external returns (bool);
    function unregister(address layer2) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface ISeigManager {
    function registry() external view returns (address);
    function depositManager() external view returns (address);
    function ton() external view returns (address);
    function wton() external view returns (address);
    function powerton() external view returns (address);
    function tot() external view returns (address);
    function coinages(address layer2) external view returns (address);
    function commissionRates(address layer2) external view returns (uint256);

    function lastCommitBlock(address layer2) external view returns (uint256);
    function seigPerBlock() external view returns (uint256);
    function lastSeigBlock() external view returns (uint256);
    function pausedBlock() external view returns (uint256);
    function unpausedBlock() external view returns (uint256);
    function DEFAULT_FACTOR() external view returns (uint256);

    function deployCoinage(address layer2) external returns (bool);
    function setCommissionRate(address layer2, uint256 commission, bool isCommissionRateNegative) external returns (bool);

    function uncomittedStakeOf(address layer2, address account) external view returns (uint256);
    function stakeOf(address layer2, address account) external view returns (uint256);
    function additionalTotBurnAmount(address layer2, address account, uint256 amount) external view returns (uint256 totAmount);

    function onTransfer(address sender, address recipient, uint256 amount) external returns (bool);
    function updateSeigniorage() external returns (bool);
    function onDeposit(address layer2, address account, uint256 amount) external returns (bool);
    function onWithdraw(address layer2, address account, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface IDAOVault {
    function setTON(address _ton) external;
    function setWTON(address _wton) external;
    function approveTON(address _to, uint256 _amount) external;
    function approveWTON(address _to, uint256 _amount) external;
    function approveERC20(address _token, address _to, uint256 _amount) external;
    function claimTON(address _to, uint256 _amount) external;
    function claimWTON(address _to, uint256 _amount) external;
    function claimERC20(address _token, address _to, uint256 _amount) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import { IStorageStateCommittee } from "IStorageStateCommittee.sol";

interface IDAOCommittee is IStorageStateCommittee {
    //--owner
    function setSeigManager(address _seigManager) external;
    function setCandidatesSeigManager(address[] calldata _candidateContracts, address _seigManager) external;
    function setCandidatesCommittee(address[] calldata _candidateContracts, address _committee) external;
    function setLayer2Registry(address _layer2Registry) external;
    function setAgendaManager(address _agendaManager) external;
    function setCandidateFactory(address _candidateFactory) external;
    function setTon(address _ton) external;
    function setActivityRewardPerSecond(uint256 _value) external;
    function setDaoVault(address _daoVault) external;

    function increaseMaxMember(uint256 _newMaxMember, uint256 _quorum) external;
    function decreaseMaxMember(uint256 _reducingMemberIndex, uint256 _quorum) external;
    function createCandidate(string calldata _memo) external;
    function registerLayer2Candidate(address _layer2, string memory _memo) external;
    function registerLayer2CandidateByOwner(address _operator, address _layer2, string memory _memo) external;
    function changeMember(uint256 _memberIndex) external returns (bool);
    function retireMember() external returns (bool);
    function setMemoOnCandidate(address _candidate, string calldata _memo) external;
    function setMemoOnCandidateContract(address _candidate, string calldata _memo) external;

    function onApprove(
        address owner,
        address spender,
        uint256 tonAmount,
        bytes calldata data
    )
        external
        returns (bool);

    function setQuorum(uint256 _quorum) external;
    function setCreateAgendaFees(uint256 _fees) external;
    function setMinimumNoticePeriodSeconds(uint256 _minimumNoticePeriod) external;
    function setMinimumVotingPeriodSeconds(uint256 _minimumVotingPeriod) external;
    function setExecutingPeriodSeconds(uint256 _executingPeriodSeconds) external;
    function castVote(uint256 _AgendaID, uint256 _vote, string calldata _comment) external;
    function endAgendaVoting(uint256 _agendaID) external;
    function executeAgenda(uint256 _AgendaID) external;
    function setAgendaStatus(uint256 _agendaID, uint256 _status, uint256 _result) external;

    function updateSeigniorage(address _candidate) external returns (bool);
    function updateSeigniorages(address[] calldata _candidates) external returns (bool);
    function claimActivityReward(address _receiver) external;

    function isCandidate(address _candidate) external view returns (bool);
    function totalSupplyOnCandidate(address _candidate) external view returns (uint256);
    function balanceOfOnCandidate(address _candidate, address _account) external view returns (uint256);
    function totalSupplyOnCandidateContract(address _candidateContract) external view returns (uint256);
    function balanceOfOnCandidateContract(address _candidateContract, address _account) external view returns (uint256);
    function candidatesLength() external view returns (uint256);
    function isExistCandidate(address _candidate) external view returns (bool);
    function getClaimableActivityReward(address _candidate) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface ILayer2 {
  function operator() external view returns (address);
  function isLayer2() external view returns (bool);
  function currentFork() external view returns (uint);
  function lastEpoch(uint forkNumber) external view returns (uint);
  function changeOperator(address _operator) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;

import { ICandidateFactory } from "ICandidateFactory.sol";
import { ILayer2Registry } from "ILayer2Registry.sol";
import { ISeigManager } from "ISeigManager.sol";
import { IDAOAgendaManager } from "IDAOAgendaManager.sol";
import { IDAOVault } from "IDAOVault.sol";

interface IStorageStateCommittee {
    struct CandidateInfo {
        address candidateContract;
        uint256 indexMembers;
        uint128 memberJoinedTime;
        uint128 rewardPeriod;
        uint128 claimedTimestamp;
    }

    function ton() external returns (address);
    function daoVault() external returns (IDAOVault);
    function agendaManager() external returns (IDAOAgendaManager);
    function candidateFactory() external returns (ICandidateFactory);
    function layer2Registry() external returns (ILayer2Registry);
    function seigManager() external returns (ISeigManager);
    function candidates(uint256 _index) external returns (address);
    function members(uint256 _index) external returns (address);
    function maxMember() external returns (uint256);
    function candidateInfos(address _candidate) external returns (CandidateInfo memory);
    function quorum() external returns (uint256);
    function activityRewardPerSecond() external returns (uint256);

    function isMember(address _candidate) external returns (bool);
    function candidateContract(address _candidate) external returns (address);
}

{
  "remappings": [
    ":g=/dir"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "istanbul",
  "metadata": {
    "useLiteralContent": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_ton","type":"address"},{"internalType":"address","name":"_impl","type":"address"},{"internalType":"address","name":"_seigManager","type":"address"},{"internalType":"address","name":"_layer2Registry","type":"address"},{"internalType":"address","name":"_agendaManager","type":"address"},{"internalType":"address","name":"_candidateFactory","type":"address"},{"internalType":"address","name":"_daoVault","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activityRewardPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"agendaManager","outputs":[{"internalType":"contract IDAOAgendaManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_candidate","type":"address"}],"name":"candidateContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"candidateFactory","outputs":[{"internalType":"contract ICandidateFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_candidate","type":"address"}],"name":"candidateInfos","outputs":[{"components":[{"internalType":"address","name":"candidateContract","type":"address"},{"internalType":"uint256","name":"indexMembers","type":"uint256"},{"internalType":"uint128","name":"memberJoinedTime","type":"uint128"},{"internalType":"uint128","name":"rewardPeriod","type":"uint128"},{"internalType":"uint128","name":"claimedTimestamp","type":"uint128"}],"internalType":"struct IStorageStateCommittee.CandidateInfo","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"candidates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"daoVault","outputs":[{"internalType":"contract IDAOVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_candidate","type":"address"}],"name":"isMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"layer2Registry","outputs":[{"internalType":"contract ILayer2Registry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMember","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"members","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseProxy","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quorum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seigManager","outputs":[{"internalType":"contract ISeigManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_pause","type":"bool"}],"name":"setProxyPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ton","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"impl","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101a95760003560e01c806363a8fd89116100f9578063a217fddf11610097578063ca15c87311610071578063ca15c87314610337578063cc48b9471461034a578063cf2a239c14610352578063d547741f1461035a576101a9565b8063a217fddf14610314578063a230c5241461031c578063b5dd11581461032f576101a9565b80637cb00d25116100d35780637cb00d25146102d35780637f331636146102e65780639010d07c146102ee57806391d1485414610301576101a9565b806363a8fd89146102b0578063651d08cd146102b85780636fb7f558146102cb576101a9565b80632f2ff15d116101665780633659cfe6116101405780633659cfe61461027a5780635903bd6c1461028d5780635c60da1b146102955780635daf08ca1461029d576101a9565b80632f2ff15d146102415780633477ee2e1461025457806336568abe14610267576101a9565b806301ffc9a7146101b357806303e3c9ac146101dc5780631703a018146101f1578063248a9ca3146101f957806327fd92fd1461020c5780632e011c1e14610221575b6101b161036d565b005b6101c66101c1366004610bc3565b6103e4565b6040516101d39190610bff565b60405180910390f35b6101e4610407565b6040516101d39190610c0a565b6101e461040d565b6101e4610207366004610b5f565b610413565b610214610428565b6040516101d39190610beb565b61023461022f366004610b1e565b610437565b6040516101d39190610d43565b6101b161024f366004610b77565b6104aa565b610214610262366004610b5f565b610511565b6101b1610275366004610b77565b61053b565b6101b1610288366004610b1e565b61059c565b610214610663565b610214610672565b6102146102ab366004610b5f565b610681565b6101c6610691565b6102146102c6366004610b1e565b6106a1565b6102146106bf565b6101b16102e1366004610b38565b6106ce565b6101e4610713565b6102146102fc366004610ba2565b610719565b6101c661030f366004610b77565b61073a565b6101e4610752565b6101c661032a366004610b1e565b610757565b610214610780565b6101e4610345366004610b5f565b61078f565b6102146107a6565b6102146107b5565b6101b1610368366004610b77565b6107c4565b6000610377610672565b90506001600160a01b0381161580159061039b5750600e54600160a01b900460ff16155b6103c05760405162461bcd60e51b81526004016103b790610cf2565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156103df573d6000f35b3d6000fd5b6001600160e01b031981166000908152600d602052604090205460ff165b919050565b60085481565b600a5481565b6000908152600c602052604090206002015490565b6002546001600160a01b031681565b61043f610ad9565b506001600160a01b03908116600090815260096020908152604091829020825160a0810184528154909416845260018101549184019190915260028101546001600160801b0380821693850193909352600160801b9004821660608401526003015416608082015290565b6000828152600c60205260409020600201546104c89061030f610832565b6105035760405162461bcd60e51b815260040180806020018281038252602f815260200180610db5602f913960400191505060405180910390fd5b61050d8282610836565b5050565b6006818154811061052157600080fd5b6000918252602090912001546001600160a01b0316905081565b610543610832565b6001600160a01b0316816001600160a01b0316146105925760405162461bcd60e51b815260040180806020018281038252602f815260200180610e14602f913960400191505060405180910390fd5b61050d828261089f565b6105a760003361073a565b6105c35760405162461bcd60e51b81526004016103b790610c13565b600e546001600160a01b03166105eb5760405162461bcd60e51b81526004016103b790610cbd565b600e546001600160a01b03828116911614156106195760405162461bcd60e51b81526004016103b790610c60565b600e80546001600160a01b0319166001600160a01b0383169081179091556040517fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b6001546001600160a01b031681565b600e546001600160a01b031690565b6007818154811061052157600080fd5b600e54600160a01b900460ff1681565b6001600160a01b039081166000908152600960205260409020541690565b6005546001600160a01b031681565b6106d960003361073a565b6106f55760405162461bcd60e51b81526004016103b790610c13565b600e8054911515600160a01b0260ff60a01b19909216919091179055565b600b5481565b6000828152600c602052604081206107319083610908565b90505b92915050565b6000828152600c602052604081206107319083610914565b600081565b6001600160a01b03166000908152600960205260409020600201546001600160801b0316151590565b6003546001600160a01b031681565b6000818152600c6020526040812061073490610929565b6000546001600160a01b031681565b6004546001600160a01b031681565b6000828152600c60205260409020600201546107e29061030f610832565b6105925760405162461bcd60e51b8152600401808060200182810382526030815260200180610de46030913960400191505060405180910390fd5b6000610731836001600160a01b038416610934565b3390565b6000828152600c6020526040902061084e908261081d565b1561050d5761085b610832565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000828152600c602052604090206108b7908261097e565b1561050d576108c4610832565b6001600160a01b0316816001600160a01b0316837ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a45050565b60006107318383610993565b6000610731836001600160a01b0384166109f7565b600061073482610a0f565b600061094083836109f7565b61097657508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155610734565b506000610734565b6000610731836001600160a01b038416610a13565b815460009082106109d55760405162461bcd60e51b8152600401808060200182810382526022815260200180610d936022913960400191505060405180910390fd5b8260000182815481106109e457fe5b9060005260206000200154905092915050565b60009081526001919091016020526040902054151590565b5490565b60008181526001830160205260408120548015610acf5783546000198083019190810190600090879083908110610a4657fe5b9060005260206000200154905080876000018481548110610a6357fe5b600091825260208083209091019290925582815260018981019092526040902090840190558654879080610a9357fe5b60019003818190600052602060002001600090559055866001016000878152602001908152602001600020600090556001945050505050610734565b6000915050610734565b6040805160a08101825260008082526020820181905291810182905260608101829052608081019190915290565b80356001600160a01b038116811461040257600080fd5b600060208284031215610b2f578081fd5b61073182610b07565b600060208284031215610b49578081fd5b81358015158114610b58578182fd5b9392505050565b600060208284031215610b70578081fd5b5035919050565b60008060408385031215610b89578081fd5b82359150610b9960208401610b07565b90509250929050565b60008060408385031215610bb4578182fd5b50508035926020909101359150565b600060208284031215610bd4578081fd5b81356001600160e01b031981168114610b58578182fd5b6001600160a01b0391909116815260200190565b901515815260200190565b90815260200190565b6020808252602d908201527f44414f436f6d6d697474656550726f78793a206d73672e73656e64657220697360408201526c103737ba1030b71030b236b4b760991b606082015260800190565b60208082526039908201527f44414f436f6d6d697474656550726f78793a2054686520696e7075742061646460408201527f726573732069732073616d652061732074686520737461746500000000000000606082015260800190565b6020808252818101527f44414f436f6d6d697474656550726f78793a20696e707574206973207a65726f604082015260600190565b60208082526031908201527f44414f436f6d6d697474656550726f78793a20696d706c206973207a65726f206040820152704f522070726f78792069732066616c736560781b606082015260800190565b81516001600160a01b03168152602080830151908201526040808301516001600160801b0390811691830191909152606080840151821690830152608092830151169181019190915260a0019056fe456e756d657261626c655365743a20696e646578206f7574206f6620626f756e6473416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e2061646d696e20746f206772616e74416363657373436f6e74726f6c3a2073656e646572206d75737420626520616e2061646d696e20746f207265766f6b65416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636520726f6c657320666f722073656c66a2646970667358221220d4f32afee42fb95ee3847bf59f929910d5c7f6ba296cb06d8352b7a95595424e64736f6c63430007060033

0000000000000000000000002be5e8c109e2197d077d13a82daead6a9b3433c5000000000000000000000000d1a3fddccd09cebcfcc7845ddba666b7b8e6d1fb000000000000000000000000710936500ac59e8551331871cbad3d33d5e0d9090000000000000000000000000b3e174a2170083e770d5d4cf56774d221b7063e000000000000000000000000cd4421d082752f363e1687544a09d5112cd4f484000000000000000000000000e6713af11adb0cfd3c60e15b23e43f5548c329420000000000000000000000002520cd65baa2ceee9e6ad6ebd3f45490c42dd303

-----Decoded View---------------
Arg [0] : _ton (address): 0x2be5e8c109e2197D077D13A82dAead6a9b3433C5
Arg [1] : _impl (address): 0xd1A3fDDCCD09ceBcFCc7845dDba666B7B8e6D1fb
Arg [2] : _seigManager (address): 0x710936500aC59e8551331871Cbad3D33d5e0D909
Arg [3] : _layer2Registry (address): 0x0b3E174A2170083e770D5d4Cf56774D221b7063e
Arg [4] : _agendaManager (address): 0xcD4421d082752f363E1687544a09d5112cD4f484
Arg [5] : _candidateFactory (address): 0xE6713aF11aDB0cFD3C60e15b23E43f5548C32942
Arg [6] : _daoVault (address): 0x2520CD65BAa2cEEe9E6Ad6EBD3F45490C42dd303

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000002be5e8c109e2197d077d13a82daead6a9b3433c5
Arg [1] : 000000000000000000000000d1a3fddccd09cebcfcc7845ddba666b7b8e6d1fb
Arg [2] : 000000000000000000000000710936500ac59e8551331871cbad3d33d5e0d909
Arg [3] : 0000000000000000000000000b3e174a2170083e770d5d4cf56774d221b7063e
Arg [4] : 000000000000000000000000cd4421d082752f363e1687544a09d5112cd4f484
Arg [5] : 000000000000000000000000e6713af11adb0cfd3c60e15b23e43f5548c32942
Arg [6] : 0000000000000000000000002520cd65baa2ceee9e6ad6ebd3f45490c42dd303

203:3252:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2480:11;:9;:11::i;:::-;203:3252;963:140:5;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1019:33:22;;;:::i;:::-;;;;;;;:::i;1169:30::-;;;:::i;4255:112:0:-;;;;;;:::i;:::-;;:::i;730:47:22:-;;;:::i;:::-;;;;;;;:::i;2539:144::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4617:223:0:-;;;;;;:::i;:::-;;:::i;938:36:22:-;;;;;;:::i;:::-;;:::i;5791:205:0:-;;;;;;:::i;:::-;;:::i;2036:307:4:-;;;;;;:::i;:::-;;:::i;690:34:22:-;;;:::i;2349:95:4:-;;;:::i;980:33:22:-;;;;;;:::i;:::-;;:::i;322:22:4:-;;;:::i;2378:155:22:-;;;;;;:::i;:::-;;:::i;891:40::-;;;:::i;1839:91:4:-;;;;;;:::i;:::-;;:::i;1206:47:22:-;;;:::i;3938:136:0:-;;;;;;:::i;:::-;;:::i;2923:137::-;;;;;;:::i;:::-;;:::i;1700:49::-;;;:::i;2226:146:22:-;;;;;;:::i;:::-;;:::i;783:50::-;;;:::i;3228:125:0:-;;;;;;:::i;:::-;;:::i;657:27:22:-;;;:::i;839:46::-;;;:::i;5074:226:0:-;;;;;;:::i;:::-;;:::i;2504:949:4:-;2544:13;2560:16;:14;:16::i;:::-;2544:32;-1:-1:-1;;;;;;2594:19:4;;;;;;:34;;-1:-1:-1;2618:10:4;;-1:-1:-1;;;2618:10:4;;;;2617:11;2594:34;2586:96;;;;-1:-1:-1;;;2586:96:4;;;;;;;:::i;:::-;;;;;;;;;2961:14;2958:1;2955;2942:34;3166:1;3163;3147:14;3144:1;3137:5;3130;3117:51;3242:16;3239:1;3236;3221:38;3280:6;3347:38;;;;3418:16;3415:1;3408:27;3347:38;3366:16;3363:1;3356:27;963:140:5;-1:-1:-1;;;;;;1063:33:5;;1040:4;1063:33;;;:20;:33;;;;;;;;963:140;;;;:::o;1019:33:22:-;;;;:::o;1169:30::-;;;;:::o;4255:112:0:-;4312:7;4338:12;;;:6;:12;;;;;:22;;;;4255:112::o;730:47:22:-;;;-1:-1:-1;;;;;730:47:22;;:::o;2539:144::-;2610:20;;:::i;:::-;-1:-1:-1;;;;;;2649:27:22;;;;;;;:15;:27;;;;;;;;;2642:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2642:34:22;;;;;;;;;;-1:-1:-1;;;2642:34:22;;;;;;;;;;;;;;;;;2539:144::o;4617:223:0:-;4708:12;;;;:6;:12;;;;;:22;;;4700:45;;4732:12;:10;:12::i;4700:45::-;4692:105;;;;-1:-1:-1;;;4692:105:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4808:25;4819:4;4825:7;4808:10;:25::i;:::-;4617:223;;:::o;938:36:22:-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;938:36:22;;-1:-1:-1;938:36:22;:::o;5791:205:0:-;5888:12;:10;:12::i;:::-;-1:-1:-1;;;;;5877:23:0;:7;-1:-1:-1;;;;;5877:23:0;;5869:83;;;;-1:-1:-1;;;5869:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5963:26;5975:4;5981:7;5963:11;:26::i;2036:307:4:-;443:39;1745:4:0;471:10:4;443:7;:39::i;:::-;435:97;;;;-1:-1:-1;;;435:97:4;;;;;;;:::i;:::-;2106:15:::1;::::0;-1:-1:-1;;;;;2106:15:4::1;2098:74;;;;-1:-1:-1::0;;;2098:74:4::1;;;;;;;:::i;:::-;2190:15;::::0;-1:-1:-1;;;;;2190:23:4;;::::1;:15:::0;::::1;:23;;2182:93;;;;-1:-1:-1::0;;;2182:93:4::1;;;;;;;:::i;:::-;2285:15;:22:::0;;-1:-1:-1;;;;;;2285:22:4::1;-1:-1:-1::0;;;;;2285:22:4;::::1;::::0;;::::1;::::0;;;2322:14:::1;::::0;::::1;::::0;-1:-1:-1;;2322:14:4::1;2036:307:::0;:::o;690:34:22:-;;;-1:-1:-1;;;;;690:34:22;;:::o;2349:95:4:-;2422:15;;-1:-1:-1;;;;;2422:15:4;2349:95;:::o;980:33:22:-;;;;;;;;;;;;322:22:4;;;-1:-1:-1;;;322:22:4;;;;;:::o;2378:155:22:-;-1:-1:-1;;;;;2481:27:22;;;2455:7;2481:27;;;:15;:27;;;;;:45;;;2378:155::o;891:40::-;;;-1:-1:-1;;;;;891:40:22;;:::o;1839:91:4:-;443:39;1745:4:0;471:10:4;443:7;:39::i;:::-;435:97;;;;-1:-1:-1;;;435:97:4;;;;;;;:::i;:::-;1904:10:::1;:19:::0;;;::::1;;-1:-1:-1::0;;;1904:19:4::1;-1:-1:-1::0;;;;1904:19:4;;::::1;::::0;;;::::1;::::0;;1839:91::o;1206:47:22:-;;;;:::o;3938:136:0:-;4011:7;4037:12;;;:6;:12;;;;;:30;;4061:5;4037:23;:30::i;:::-;4030:37;;3938:136;;;;;:::o;2923:137::-;2992:4;3015:12;;;:6;:12;;;;;:38;;3045:7;3015:29;:38::i;1700:49::-;1745:4;1700:49;:::o;2226:146:22:-;-1:-1:-1;;;;;2317:27:22;2294:4;2317:27;;;:15;:27;;;;;:44;;;-1:-1:-1;;;;;2317:44:22;:48;;;2226:146::o;783:50::-;;;-1:-1:-1;;;;;783:50:22;;:::o;3228:125:0:-;3291:7;3317:12;;;:6;:12;;;;;:29;;:27;:29::i;657:27:22:-;;;-1:-1:-1;;;;;657:27:22;;:::o;839:46::-;;;-1:-1:-1;;;;;839:46:22;;:::o;5074:226:0:-;5166:12;;;;:6;:12;;;;;:22;;;5158:45;;5190:12;:10;:12::i;5158:45::-;5150:106;;;;-1:-1:-1;;;5150:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6429:141:7;6499:4;6522:41;6527:3;-1:-1:-1;;;;;6547:14:7;;6522:4;:41::i;598:104:2:-;685:10;598:104;:::o;6998:184:0:-;7071:12;;;;:6;:12;;;;;:33;;7096:7;7071:24;:33::i;:::-;7067:109;;;7152:12;:10;:12::i;:::-;-1:-1:-1;;;;;7125:40:0;7143:7;-1:-1:-1;;;;;7125:40:0;7137:4;7125:40;;;;;;;;;;6998:184;;:::o;7188:188::-;7262:12;;;;:6;:12;;;;;:36;;7290:7;7262:27;:36::i;:::-;7258:112;;;7346:12;:10;:12::i;:::-;-1:-1:-1;;;;;7319:40:0;7337:7;-1:-1:-1;;;;;7319:40:0;7331:4;7319:40;;;;;;;;;;7188:188;;:::o;7650:147:7:-;7724:7;7766:22;7770:3;7782:5;7766:3;:22::i;6966:156::-;7046:4;7069:46;7079:3;-1:-1:-1;;;;;7099:14:7;;7069:9;:46::i;7203:115::-;7266:7;7292:19;7300:3;7292:7;:19::i;1640:404::-;1703:4;1724:21;1734:3;1739:5;1724:9;:21::i;:::-;1719:319;;-1:-1:-1;1761:23:7;;;;;;;;:11;:23;;;;;;;;;;;;;1941:18;;1919:19;;;:12;;;:19;;;;;;:40;;;;1973:11;;1719:319;-1:-1:-1;2022:5:7;2015:12;;6738:147;6811:4;6834:44;6842:3;-1:-1:-1;;;;;6862:14:7;;6834:7;:44::i;4452:201::-;4546:18;;4519:7;;4546:26;-1:-1:-1;4538:73:7;;;;-1:-1:-1;;;4538:73:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4628:3;:11;;4640:5;4628:18;;;;;;;;;;;;;;;;4621:25;;4452:201;;;;:::o;3805:127::-;3878:4;3901:19;;;:12;;;;;:19;;;;;;:24;;;3805:127::o;4013:107::-;4095:18;;4013:107::o;2212:1512::-;2278:4;2415:19;;;:12;;;:19;;;;;;2449:15;;2445:1273;;2878:18;;-1:-1:-1;;2830:14:7;;;;2878:22;;;;2806:21;;2878:3;;:22;;3160;;;;;;;;;;;;;;3140:42;;3303:9;3274:3;:11;;3286:13;3274:26;;;;;;;;;;;;;;;;;;;:38;;;;3378:23;;;3420:1;3378:12;;;:23;;;;;;3404:17;;;3378:43;;3527:17;;3378:3;;3527:17;;;;;;;;;;;;;;;;;;;;;;3619:3;:12;;:19;3632:5;3619:19;;;;;;;;;;;3612:26;;;3660:4;3653:11;;;;;;;;2445:1273;3702:5;3695:12;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:175:23:-;84:20;;-1:-1:-1;;;;;133:31:23;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:293::-;;506:2;494:9;485:7;481:23;477:32;474:2;;;527:6;519;512:22;474:2;571:9;558:23;624:5;617:13;610:21;603:5;600:32;590:2;;651:6;643;636:22;590:2;679:5;464:226;-1:-1:-1;;;464:226:23:o;695:190::-;;807:2;795:9;786:7;782:23;778:32;775:2;;;828:6;820;813:22;775:2;-1:-1:-1;856:23:23;;765:120;-1:-1:-1;765:120:23:o;890:266::-;;;1019:2;1007:9;998:7;994:23;990:32;987:2;;;1040:6;1032;1025:22;987:2;1081:9;1068:23;1058:33;;1110:40;1146:2;1135:9;1131:18;1110:40;:::i;:::-;1100:50;;977:179;;;;;:::o;1161:258::-;;;1290:2;1278:9;1269:7;1265:23;1261:32;1258:2;;;1311:6;1303;1296:22;1258:2;-1:-1:-1;;1339:23:23;;;1409:2;1394:18;;;1381:32;;-1:-1:-1;1248:171:23:o;1424:306::-;;1535:2;1523:9;1514:7;1510:23;1506:32;1503:2;;;1556:6;1548;1541:22;1503:2;1587:23;;-1:-1:-1;;;;;;1639:32:23;;1629:43;;1619:2;;1691:6;1683;1676:22;1930:203;-1:-1:-1;;;;;2094:32:23;;;;2076:51;;2064:2;2049:18;;2031:102::o;2138:187::-;2303:14;;2296:22;2278:41;;2266:2;2251:18;;2233:92::o;2330:177::-;2476:25;;;2464:2;2449:18;;2431:76::o;3667:409::-;3869:2;3851:21;;;3908:2;3888:18;;;3881:30;3947:34;3942:2;3927:18;;3920:62;-1:-1:-1;;;4013:2:23;3998:18;;3991:43;4066:3;4051:19;;3841:235::o;4081:421::-;4283:2;4265:21;;;4322:2;4302:18;;;4295:30;4361:34;4356:2;4341:18;;4334:62;4432:27;4427:2;4412:18;;4405:55;4492:3;4477:19;;4255:247::o;4507:356::-;4709:2;4691:21;;;4728:18;;;4721:30;4787:34;4782:2;4767:18;;4760:62;4854:2;4839:18;;4681:182::o;4868:413::-;5070:2;5052:21;;;5109:2;5089:18;;;5082:30;5148:34;5143:2;5128:18;;5121:62;-1:-1:-1;;;5214:2:23;5199:18;;5192:47;5271:3;5256:19;;5042:239::o;5286:646::-;5517:13;;-1:-1:-1;;;;;5513:39:23;5495:58;;5609:4;5597:17;;;5591:24;5569:20;;;5562:54;5663:4;5651:17;;;5645:24;-1:-1:-1;;;;;5760:21:23;;;5738:20;;;5731:51;;;;5842:4;5830:17;;;5824:24;5820:33;;5798:20;;;5791:63;5914:4;5902:17;;;5896:24;5892:33;5870:20;;;5863:63;;;;5482:3;5467:19;;5449:483::o

ipfs://d4f32afee42fb95ee3847bf59f929910d5c7f6ba296cb06d8352b7a95595424e