More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 14,363 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 18276067 | 276 days ago | IN | 0 ETH | 0.00093991 | ||||
Withdraw | 18276049 | 276 days ago | IN | 0 ETH | 0.00118872 | ||||
Withdraw | 18276035 | 276 days ago | IN | 0 ETH | 0.001127 | ||||
Withdraw | 18275998 | 276 days ago | IN | 0 ETH | 0.00086977 | ||||
Slave Withdraw | 18275940 | 276 days ago | IN | 0 ETH | 0.00127008 | ||||
Slave Withdraw | 18275917 | 276 days ago | IN | 0 ETH | 0.00121513 | ||||
Withdraw | 18265569 | 278 days ago | IN | 0 ETH | 0.00196123 | ||||
Slave Withdraw | 18264934 | 278 days ago | IN | 0 ETH | 0.00526899 | ||||
Slave Withdraw | 18253732 | 279 days ago | IN | 0 ETH | 0.00126557 | ||||
Slave Withdraw | 18253701 | 279 days ago | IN | 0 ETH | 0.00110745 | ||||
Slave Withdraw | 18253566 | 279 days ago | IN | 0 ETH | 0.00101874 | ||||
Withdraw | 11724071 | 1258 days ago | IN | 0 ETH | 0.00800663 | ||||
Slave Withdraw | 11698477 | 1262 days ago | IN | 0 ETH | 0.00887808 | ||||
Slave Withdraw | 11640224 | 1271 days ago | IN | 0 ETH | 0.00794515 | ||||
Slave Withdraw | 11443089 | 1301 days ago | IN | 0 ETH | 0.00279616 | ||||
Slave Withdraw | 11436247 | 1302 days ago | IN | 0 ETH | 0.00321505 | ||||
Deposit | 11436176 | 1302 days ago | IN | 0 ETH | 0.00214859 | ||||
Deposit | 11436173 | 1302 days ago | IN | 0 ETH | 0.00366154 | ||||
Slave Deposit | 11436166 | 1302 days ago | IN | 0 ETH | 0.00350262 | ||||
Slave Withdraw | 11429264 | 1303 days ago | IN | 0 ETH | 0.00537468 | ||||
Slave Deposit | 11429249 | 1303 days ago | IN | 0 ETH | 0.00719634 | ||||
Slave Withdraw | 11423589 | 1304 days ago | IN | 0 ETH | 0.00199555 | ||||
Slave Deposit | 11422848 | 1304 days ago | IN | 0 ETH | 0.00349074 | ||||
Deposit | 11373018 | 1312 days ago | IN | 0 ETH | 0.00282124 | ||||
Withdraw | 11353806 | 1315 days ago | IN | 0 ETH | 0.00193433 |
Latest 15 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
11143812 | 1347 days ago | 1 ETH | ||||
11143809 | 1347 days ago | 1 ETH | ||||
11143809 | 1347 days ago | 1 ETH | ||||
11143808 | 1347 days ago | 1 ETH | ||||
11143808 | 1347 days ago | 1 ETH | ||||
11143807 | 1347 days ago | 1 ETH | ||||
11143806 | 1347 days ago | 2 ETH | ||||
11143804 | 1347 days ago | 9 ETH | ||||
11143790 | 1347 days ago | 5 ETH | ||||
11142830 | 1347 days ago | 1 ETH | ||||
11142823 | 1347 days ago | 1 ETH | ||||
11142815 | 1347 days ago | 1 ETH | ||||
11129394 | 1349 days ago | 1 ETH | ||||
11129359 | 1349 days ago | 1 ETH | ||||
11129337 | 1349 days ago | 1 ETH |
Loading...
Loading
Contract Name:
LightMain
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-10-04 */ // File: @openzeppelin/contracts/token/ERC20/IERC20.sol pragma solidity ^0.6.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); } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.6.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; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.6.2; /** * @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) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @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"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); 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); } } } } // File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol pragma solidity ^0.6.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File: @openzeppelin/contracts/utils/EnumerableSet.sol pragma solidity ^0.6.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.0.0, only sets of type `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]; } // 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)); } } // File: @openzeppelin/contracts/GSN/Context.sol pragma solidity ^0.6.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; } } // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity ^0.6.0; /** * @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. */ 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; } } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol pragma solidity ^0.6.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } // File: contracts/LightToken.sol pragma solidity 0.6.12; // LightToken with Governance. contract LightToken is ERC20("LightToken", "LIGHT"), Ownable { /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (LightMain). function mint(address _to, uint256 _amount) public onlyOwner { _mint(_to, _amount); _moveDelegates(address(0), _delegates[_to], _amount); } // Copied and modified from YAM code: // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol // Which is copied and modified from COMPOUND: // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol /// @notice A record of each accounts delegate mapping (address => address) internal _delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint256 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegator The address to get delegatee for */ function delegates(address delegator) external view returns (address) { return _delegates[delegator]; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) external { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig( address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s ) external { bytes32 domainSeparator = keccak256( abi.encode( DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this) ) ); bytes32 structHash = keccak256( abi.encode( DELEGATION_TYPEHASH, delegatee, nonce, expiry ) ); bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", domainSeparator, structHash ) ); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "LIGHT::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "LIGHT::delegateBySig: invalid nonce"); require(now <= expiry, "LIGHT::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint256) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) external view returns (uint256) { require(blockNumber < block.number, "LIGHT::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = _delegates[delegator]; uint256 delegatorBalance = balanceOf(delegator); // balance of underlying LIGHTs (not scaled); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { // decrease old representative uint32 srcRepNum = numCheckpoints[srcRep]; uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint256 srcRepNew = srcRepOld.sub(amount); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { // increase new representative uint32 dstRepNum = numCheckpoints[dstRep]; uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint256 dstRepNew = dstRepOld.add(amount); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32(block.number, "LIGHT::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } // File: contracts/LightMain.sol interface IMigratorLight { enum Platform{ uniswap, sushiswap } // Perform LP token migration from legacy UniswapV2 to LightSwap. // Take the current LP token address and return the new LP token address. // Migrator should have full access to the caller's LP token. // Return the new LP token address. // // XXX Migrator must have allowance access to UniswapV2 LP tokens. // LightSwap must mint EXACTLY the same amount of LightSwap LP tokens or // else something bad will happen. Traditional UniswapV2 does not // do that so be careful! function migrate(IERC20 token, Platform platform) external returns (IERC20); } // LightMain is the master of Light. He can make Light and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once LIGHT is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless. contract LightMain is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; uint256 public constant MinMinters = 20; enum Region{ master, slave } // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of LIGHTs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accLightPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accLightPerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. uint256 accReward; } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. LIGHTs to distribute per block. uint256 lastRewardBlock; // Last block number that LIGHTs distribution occurs. uint256 accLightPerShare; // Accumulated LIGHTs per share, times 1e12. See below. // Lock LP, until the end of mining. bool lock; } // The LIGHT TOKEN! LightToken public light; // LIGHT tokens created per block. uint256 public lightPerBlock; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorLight public migrator; // The buy back contract. address public buyBackContract; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping (uint256 => mapping (address => UserInfo)) public userInfo; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when LIGHT mining starts. uint256 public startBlock; uint256 public halfPeriod; uint256 public maxBlocks; uint256 public maxSupply; uint256 public createAreaFee; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); constructor( LightToken _light, uint256 _createAreaFee, uint256 _lightPerBlock, uint256 _startBlock, uint256 _halfPeriod, uint256 _maxBlocks, uint256 _maxSupply ) public { light = _light; createAreaFee = _createAreaFee; lightPerBlock = _lightPerBlock; startBlock = _startBlock; halfPeriod = _halfPeriod; maxBlocks = _maxBlocks; maxSupply = _maxSupply; } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate, bool _lock) public onlyOwner { if (_withUpdate) { massUpdatePools(Region.master); } uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push(PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accLightPerShare: 0, lock: _lock })); } // Update the given pool's LIGHT allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(Region.master); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // View function to see pending LIGHTs on frontend. function pendingLight(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accLightPerShare = pool.accLightPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 blockRewards = getBlockRewards(pool.lastRewardBlock, block.number, Region.master); uint256 lightReward = blockRewards.mul(pool.allocPoint).div(totalAllocPoint); accLightPerShare = accLightPerShare.add(lightReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accLightPerShare).div(1e12).sub(user.rewardDebt); } // Update reward variables for all pools. Be careful of gas spending! function massUpdatePools(Region region) public { if(region == Region.master){ uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } }else if(region == Region.master){ uint256 length = slavePoolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updateSlavePool(pid); } } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 blockRewards = getBlockRewards(pool.lastRewardBlock, block.number, Region.master); uint256 lightReward = blockRewards.mul(pool.allocPoint).div(totalAllocPoint); light.mint(address(this), lightReward); pool.accLightPerShare = pool.accLightPerShare.add(lightReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to LightMain for LIGHT allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accLightPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { safeLightTransfer(msg.sender, pending); user.accReward = user.accReward.add(pending); } } if(_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); user.amount = user.amount.add(_amount); } user.rewardDebt = user.amount.mul(pool.accLightPerShare).div(1e12); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from LightMain. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; require(pool.lock == false || pool.lock && block.number >= (startBlock + maxBlocks + 5760)); UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accLightPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { safeLightTransfer(msg.sender, pending); user.accReward = user.accReward.add(pending); } if(_amount > 0) { user.amount = user.amount.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); } user.rewardDebt = user.amount.mul(pool.accLightPerShare).div(1e12); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; pool.lpToken.safeTransfer(address(msg.sender), user.amount); emit EmergencyWithdraw(msg.sender, _pid, user.amount); user.amount = 0; user.rewardDebt = 0; } // Safe light transfer function, just in case if rounding error causes pool to not have enough LIGHTs. function safeLightTransfer(address _to, uint256 _amount) internal { uint256 lightBal = light.balanceOf(address(this)); if (_amount > lightBal) { light.transfer(_to, lightBal); } else { light.transfer(_to, _amount); } } // Reduce by 50% per halfPeriod blocks. function getBlockReward(uint256 number, Region region) public view returns (uint256) { if (number < startBlock){ return 0; } uint256 mintBlocks = number.sub(startBlock); if (mintBlocks >= maxBlocks){ return 0; } uint256 exp = mintBlocks.div(halfPeriod); uint256 blockReward = lightPerBlock.mul(5 ** exp).div(10 ** exp); if(blockReward > 0 && blockReward <= lightPerBlock){ if(region == Region.master){ return blockReward.mul(8).div(10); } if(region == Region.slave){ return blockReward.mul(2).div(10); } return blockReward; } return 0; } function getBlockRewardNow() public view returns (uint256) { return getBlockReward(block.number, Region.master) + getBlockReward(block.number, Region.slave); } function getBlockRewards(uint256 from, uint256 to, Region region) public view returns (uint256) { if(light.totalSupply() >= maxSupply){ return 0; } if(from < startBlock){ from = startBlock; } if(to > startBlock.add(maxBlocks)){ to = startBlock.add(maxBlocks).sub(1); } if(from >= to){ return 0; } uint256 blockReward1 = getBlockReward(from, region); uint256 blockReward2 = getBlockReward(to, region); uint256 blockGap = to.sub(from); if(blockReward1 != blockReward2){ uint256 blocks2 = to.mod(halfPeriod); if(blockGap < blocks2){ return 0; } uint256 blocks1 = blockGap.sub(blocks2); return blocks1.mul(blockReward1).add(blocks2.mul(blockReward2)); } return blockGap.mul(blockReward1); } // ------------------------------------------------------------ // --- SLAVE POOLs AND AREAs // ------------------------------------------------------------ event SlaveDeposit(address indexed user, uint256 indexed pid, uint256 amount); event SlaveWithdraw(address indexed user, uint256 indexed pid, uint256 amount); event SlaveEmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); // Info of each area. struct AreaInfo { address creator; uint256 creationBlock; uint256 members; uint256 amount; uint256 rewardDebt; string name; } // Info of each area that stakes LP tokens. mapping (uint256 => AreaInfo[]) public areaInfo; struct SlaveUserInfo { uint256 aid; uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of LIGHTs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accLightPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accLightPerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. uint256 accReward; } // Info of each pool. struct SlavePoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. LIGHTs to distribute per block. uint256 lastRewardBlock; // Last block number that LIGHTs distribution occurs. uint256 minerAccLightPerShare; // Accumulated LIGHTs per share, times 1e12. See below. uint256 creatorAccLightPerShare; // Accumulated LIGHTs per share, times 1e12. See below. uint256 totalBadAreaBalance; uint256 ethForBuyBack; } // Info of each pool. SlavePoolInfo[] public slavePoolInfo; // Info of each user that stakes LP tokens. mapping (uint256 => mapping (address => SlaveUserInfo)) public slaveUserInfo; uint256 public slaveTotalAllocPoint = 0; function createArea(uint256 _pid, string memory _name) payable public { require(msg.value == createAreaFee); areaInfo[_pid].push(AreaInfo({ creator: msg.sender, creationBlock: block.number, members: 0, amount: 0, rewardDebt: 0, name: _name })); // Buy back LIGHTs for creators. SlavePoolInfo storage pool = slavePoolInfo[_pid]; if(buyBackContract != address(0)){ bytes memory callData = abi.encodeWithSignature("buyBackLightForCreators(uint256)", _pid); (bool success, ) = buyBackContract.call{value: pool.ethForBuyBack.add(msg.value)}(callData); if(success){ pool.ethForBuyBack = 0; } }else{ pool.ethForBuyBack = pool.ethForBuyBack.add(createAreaFee); } } function slavePoolLength() external view returns (uint256) { return slavePoolInfo.length; } function areaLength(uint256 _pid) external view returns (uint256) { return areaInfo[_pid].length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function addSlavePool(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(Region.slave); } uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; slaveTotalAllocPoint = slaveTotalAllocPoint.add(_allocPoint); slavePoolInfo.push(SlavePoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, minerAccLightPerShare: 0, creatorAccLightPerShare: 0, totalBadAreaBalance: 0, ethForBuyBack: 0 })); } // Update the given pool's LIGHT allocation point. Can only be called by the owner. function setSlavePool(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(Region.slave); } slaveTotalAllocPoint = slaveTotalAllocPoint.sub(slavePoolInfo[_pid].allocPoint).add(_allocPoint); slavePoolInfo[_pid].allocPoint = _allocPoint; } function slavePendingLightByAid(uint256 _pid, uint256 _aid, address _user) external view returns (uint256) { if(slaveUserInfo[_pid][_user].aid != _aid){ return 0; } return slavePendingLight(_pid, _user); } // View function to see pending LIGHTs on frontend. function slavePendingLight(uint256 _pid, address _user) public view returns (uint256) { SlavePoolInfo storage pool = slavePoolInfo[_pid]; SlaveUserInfo storage user = slaveUserInfo[_pid][_user]; uint256 minerAccLightPerShare = pool.minerAccLightPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 blockRewards = getBlockRewards(pool.lastRewardBlock, block.number, Region.slave); uint256 lightReward = blockRewards.mul(pool.allocPoint).div(slaveTotalAllocPoint); uint256 lightRewardForMiner = lightReward.mul(95).div(100); minerAccLightPerShare = minerAccLightPerShare.add(lightRewardForMiner.mul(1e12).div(lpSupply)); } return user.amount.mul(minerAccLightPerShare).div(1e12).sub(user.rewardDebt); } function slavePendingLightForCreatorByAid(uint256 _pid, uint256 _aid, address _user) external view returns (uint256) { if(slaveUserInfo[_pid][_user].aid != _aid){ return 0; } return slavePendingLightForCreator(_pid, _user); } function slavePendingLightForCreator(uint256 _pid, address _user) public view returns (uint256) { SlaveUserInfo storage user = slaveUserInfo[_pid][_user]; AreaInfo storage area = areaInfo[_pid][user.aid]; if(area.creator != _user || area.members < MinMinters){ return 0; } SlavePoolInfo storage pool = slavePoolInfo[_pid]; uint256 creatorAccLightPerShare = pool.creatorAccLightPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 blockRewards = getBlockRewards(pool.lastRewardBlock, block.number, Region.slave); uint256 lightReward = blockRewards.mul(pool.allocPoint).div(slaveTotalAllocPoint); uint256 lightRewardForCreator = lightReward.mul(5).div(100); uint256 lpSupply2 = lpSupply.sub(pool.totalBadAreaBalance); if(lpSupply2 > 0){ creatorAccLightPerShare = creatorAccLightPerShare.add(lightRewardForCreator.mul(1e12).div(lpSupply2)); } } return area.amount.mul(creatorAccLightPerShare).div(1e12).sub(area.rewardDebt); } // Update reward variables of the given pool to be up-to-date. function updateSlavePool(uint256 _pid) public { SlavePoolInfo storage pool = slavePoolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 blockReward = getBlockRewards(pool.lastRewardBlock, block.number, Region.slave); uint256 lightReward = blockReward.mul(pool.allocPoint).div(slaveTotalAllocPoint); uint256 lightRewardForMiner = lightReward.mul(95).div(100); uint256 lightRewardForCreator = lightReward.sub(lightRewardForMiner); pool.minerAccLightPerShare = pool.minerAccLightPerShare.add(lightRewardForMiner.mul(1e12).div(lpSupply)); uint256 lpSupply2 = lpSupply.sub(pool.totalBadAreaBalance); if(lpSupply2 > 0){ pool.creatorAccLightPerShare = pool.creatorAccLightPerShare.add(lightRewardForCreator.mul(1e12).div(lpSupply2)); light.mint(address(this), lightReward); }else{ light.mint(address(this), lightRewardForMiner); } pool.lastRewardBlock = block.number; } // Deposit LP tokens to LightMain for LIGHT allocation. function slaveDeposit(uint256 _pid, uint256 _aid, uint256 _amount) public { AreaInfo storage area = areaInfo[_pid][_aid]; require(area.creator != address(0), "invalid area"); SlavePoolInfo storage pool = slavePoolInfo[_pid]; SlaveUserInfo storage user = slaveUserInfo[_pid][msg.sender]; updateSlavePool(_pid); if (user.amount > 0) { require(user.aid == _aid, "deposit: invalid aid"); uint256 minerPending = user.amount.mul(pool.minerAccLightPerShare).div(1e12).sub(user.rewardDebt); if(minerPending > 0) { safeLightTransfer(msg.sender, minerPending); user.accReward = user.accReward.add(minerPending); } } if(area.members >= MinMinters){ uint256 creatorPending = area.amount.mul(pool.creatorAccLightPerShare).div(1e12).sub(area.rewardDebt); if(creatorPending > 0) { safeLightTransfer(area.creator, creatorPending); SlaveUserInfo storage creatorInfo = slaveUserInfo[_pid][area.creator]; creatorInfo.accReward = creatorInfo.accReward.add(creatorPending); } } if(_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); // First deposit if(user.amount == 0){ user.aid = _aid; area.members = area.members.add(1); if(area.members == MinMinters){ pool.totalBadAreaBalance = pool.totalBadAreaBalance.sub(area.amount); } } if(area.members < MinMinters){ pool.totalBadAreaBalance = pool.totalBadAreaBalance.add(_amount); } user.amount = user.amount.add(_amount); area.amount = area.amount.add(_amount); } user.rewardDebt = user.amount.mul(pool.minerAccLightPerShare).div(1e12); area.rewardDebt = area.amount.mul(pool.creatorAccLightPerShare).div(1e12); emit SlaveDeposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from LightMain. function slaveWithdraw(uint256 _pid, uint256 _amount) public { SlavePoolInfo storage pool = slavePoolInfo[_pid]; SlaveUserInfo storage user = slaveUserInfo[_pid][msg.sender]; AreaInfo storage area = areaInfo[_pid][user.aid]; require(user.amount >= _amount, "withdraw: not good"); updateSlavePool(_pid); uint256 minerPending = user.amount.mul(pool.minerAccLightPerShare).div(1e12).sub(user.rewardDebt); if(minerPending > 0) { safeLightTransfer(msg.sender, minerPending); user.accReward = user.accReward.add(minerPending); } if(area.members >= MinMinters){ uint256 creatorPending = area.amount.mul(pool.creatorAccLightPerShare).div(1e12).sub(area.rewardDebt); if(creatorPending > 0) { safeLightTransfer(area.creator, creatorPending); SlaveUserInfo storage creatorInfo = slaveUserInfo[_pid][area.creator]; creatorInfo.accReward = creatorInfo.accReward.add(creatorPending); } } if(_amount > 0) { user.amount = user.amount.sub(_amount); if(user.amount == 0){ if(area.members == MinMinters){ pool.totalBadAreaBalance = pool.totalBadAreaBalance.add(area.amount); } area.members = area.members.sub(1); } if(area.members < MinMinters){ pool.totalBadAreaBalance = pool.totalBadAreaBalance.sub(_amount); } area.amount = area.amount.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); } area.rewardDebt = area.amount.mul(pool.creatorAccLightPerShare).div(1e12); user.rewardDebt = user.amount.mul(pool.minerAccLightPerShare).div(1e12); emit SlaveWithdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function slaveEmergencyWithdraw(uint256 _pid) public { SlavePoolInfo storage pool = slavePoolInfo[_pid]; SlaveUserInfo storage user = slaveUserInfo[_pid][msg.sender]; pool.lpToken.safeTransfer(address(msg.sender), user.amount); emit SlaveEmergencyWithdraw(msg.sender, _pid, user.amount); user.amount = 0; user.rewardDebt = 0; } function setBuyBackContract(address _buyBackContract) public onlyOwner { buyBackContract = _buyBackContract; } // Share LIGHTs for creators; function shareLightForCreators(uint256 _pid, uint256 _amount) public { SlavePoolInfo storage pool = slavePoolInfo[_pid]; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); uint256 lpSupply2 = lpSupply.sub(pool.totalBadAreaBalance); if(lpSupply2 > 0){ light.transferFrom(msg.sender, address(this), _amount); pool.creatorAccLightPerShare = pool.creatorAccLightPerShare.add(_amount.mul(1e12).div(lpSupply2)); } } function manualBuyBack(uint256 _pid) public onlyOwner { SlavePoolInfo storage pool = slavePoolInfo[_pid]; require(buyBackContract != address(0) && pool.ethForBuyBack > 0); bytes memory callData = abi.encodeWithSignature("buyBackLightForCreators(uint256)", _pid); (bool success, ) = buyBackContract.call{value: pool.ethForBuyBack}(callData); if(success){ pool.ethForBuyBack = 0; } } // --------------------------------------- // Migrate // --------------------------------------- // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorLight _migrator) public onlyOwner { migrator = _migrator; } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid, Region region, IMigratorLight.Platform platform) public { require(address(migrator) != address(0), "migrate: no migrator"); if(region == Region.master){ PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken, platform); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; }else if(region == Region.slave){ SlavePoolInfo storage pool = slavePoolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken, platform); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract LightToken","name":"_light","type":"address"},{"internalType":"uint256","name":"_createAreaFee","type":"uint256"},{"internalType":"uint256","name":"_lightPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_halfPeriod","type":"uint256"},{"internalType":"uint256","name":"_maxBlocks","type":"uint256"},{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SlaveDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SlaveEmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SlaveWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MinMinters","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"bool","name":"_lock","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"addSlavePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"areaInfo","outputs":[{"internalType":"address","name":"creator","type":"address"},{"internalType":"uint256","name":"creationBlock","type":"uint256"},{"internalType":"uint256","name":"members","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"string","name":"name","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"areaLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"string","name":"_name","type":"string"}],"name":"createArea","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"createAreaFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"number","type":"uint256"},{"internalType":"enum LightMain.Region","name":"region","type":"uint8"}],"name":"getBlockReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBlockRewardNow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"enum LightMain.Region","name":"region","type":"uint8"}],"name":"getBlockRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"halfPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"light","outputs":[{"internalType":"contract LightToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lightPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"manualBuyBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum LightMain.Region","name":"region","type":"uint8"}],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"enum LightMain.Region","name":"region","type":"uint8"},{"internalType":"enum IMigratorLight.Platform","name":"platform","type":"uint8"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrator","outputs":[{"internalType":"contract IMigratorLight","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingLight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accLightPerShare","type":"uint256"},{"internalType":"bool","name":"lock","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_buyBackContract","type":"address"}],"name":"setBuyBackContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMigratorLight","name":"_migrator","type":"address"}],"name":"setMigrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSlavePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"shareLightForCreators","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_aid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"slaveDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"slaveEmergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"slavePendingLight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_aid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"slavePendingLightByAid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"slavePendingLightForCreator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_aid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"slavePendingLightForCreatorByAid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"slavePoolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"minerAccLightPerShare","type":"uint256"},{"internalType":"uint256","name":"creatorAccLightPerShare","type":"uint256"},{"internalType":"uint256","name":"totalBadAreaBalance","type":"uint256"},{"internalType":"uint256","name":"ethForBuyBack","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slavePoolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slaveTotalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"slaveUserInfo","outputs":[{"internalType":"uint256","name":"aid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"accReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"slaveWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updateSlavePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"accReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000dbb4b96a23ea7943bb72a8f16cc2c248f3729350000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000006f05b59d3b200000000000000000000000000000000000000000000000000000000000000a7b0e8000000000000000000000000000000000000000000000000000000000000af00000000000000000000000000000000000000000000000000000000000002ee000000000000000000000000000000000000000000000008e4d316827686400000
-----Decoded View---------------
Arg [0] : _light (address): 0x0dBB4b96a23Ea7943BB72a8F16cc2c248F372935
Arg [1] : _createAreaFee (uint256): 1000000000000000000
Arg [2] : _lightPerBlock (uint256): 500000000000000000
Arg [3] : _startBlock (uint256): 10989800
Arg [4] : _halfPeriod (uint256): 44800
Arg [5] : _maxBlocks (uint256): 192000
Arg [6] : _maxSupply (uint256): 42000000000000000000000
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000dbb4b96a23ea7943bb72a8f16cc2c248f372935
Arg [1] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [2] : 00000000000000000000000000000000000000000000000006f05b59d3b20000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000a7b0e8
Arg [4] : 000000000000000000000000000000000000000000000000000000000000af00
Arg [5] : 000000000000000000000000000000000000000000000000000000000002ee00
Arg [6] : 0000000000000000000000000000000000000000000008e4d316827686400000
Deployed Bytecode Sourcemap
50595:27450:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76952:1088;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76952:1088:0;;;;;;;;;;;;;;;;:::i;:::-;;53768:95;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;52523:26;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52523:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;52523:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52766:34;;;;;;;;;;;;;:::i;52922:24::-;;;;;;;;;;;;;:::i;76726:103::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76726:103:0;-1:-1:-1;;;;;76726:103:0;;:::i;65334:113::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65334:113:0;;:::i;69524:1239::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69524:1239:0;;:::i;52890:25::-;;;;;;;;;;;;;:::i;67050:903::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67050:903:0;;;;;;-1:-1:-1;;;;;67050:903:0;;:::i;75022:386::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75022:386:0;;:::i;58150:904::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58150:904:0;;;;;;;:::i;52858:25::-;;;;;;;;;;;;;:::i;55929:466::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55929:466:0;;;;:::i;56471:741::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56471:741:0;;:::i;59125:356::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59125:356:0;;:::i;66735:250::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66735:250:0;;;;;;;;;;;-1:-1:-1;;;;;66735:250:0;;:::i;75416:124::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75416:124:0;-1:-1:-1;;;;;75416:124:0;;:::i;54694:317::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54694:317:0;;;;;;;;;;;;;;:::i;52188:23::-;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;52188:23:0;;;;;;;;;;;;;;60700:173;;;;;;;;;;;;;:::i;52258:28::-;;;;;;;;;;;;;:::i;28910:148::-;;;;;;;;;;;;;:::i;66382:345::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66382:345:0;;;;;;;;;;;;;;:::i;52459:30::-;;;;;;;;;;;;;:::i;50702:39::-;;;;;;;;;;;;;:::i;52391:30::-;;;;;;;;;;;;;:::i;28268:79::-;;;;;;;;;;;;;:::i;59935:757::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59935:757:0;;;;;;;;;:::i;55076:770::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55076:770:0;;;;;;-1:-1:-1;;;;;55076:770:0;;:::i;65221:105::-;;;;;;;;;;;;;:::i;62547:47::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62547:47:0;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;62547:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52605:66;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52605:66:0;;;;;;-1:-1:-1;;;;;52605:66:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;70832:2142;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70832:2142:0;;;;;;;;;;;;:::i;54032:565::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54032:565:0;;;-1:-1:-1;;;;;54032:565:0;;;;;;;;;;;;;;;;;;;:::i;65616:669::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65616:669:0;;;-1:-1:-1;;;;;65616:669:0;;;;;;;;;;;;:::i;52953:24::-;;;;;;;;;;;;;:::i;64188:76::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64188:76:0;;;;;;-1:-1:-1;;;;;64188:76:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64096:36;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64096:36:0;;:::i;:::-;;;;-1:-1:-1;;;;;64096:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52984:28;;;;;;;;;;;;;:::i;73025:1926::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73025:1926:0;;;;;;;:::i;57281:818::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57281:818:0;;;;;;;:::i;75583:492::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75583:492:0;;;;;;;:::i;76083:453::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76083:453:0;;:::i;64271:39::-;;;;;;;;;;;;;:::i;29213:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29213:244:0;-1:-1:-1;;;;;29213:244:0;;:::i;64319:894::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64319:894:0;;-1:-1:-1;64319:894:0;;-1:-1:-1;;;;;64319:894:0:i;68239:1209::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68239:1209:0;;;;;;-1:-1:-1;;;;;68239:1209:0;;:::i;67961:270::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67961:270:0;;;;;;;;;;;-1:-1:-1;;;;;67961:270:0;;:::i;60881:951::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60881:951:0;;;;;;;;;;;;;;:::i;76952:1088::-;77066:8;;-1:-1:-1;;;;;77066:8:0;77050:64;;;;;-1:-1:-1;;;77050:64:0;;;;;;;;;;;;-1:-1:-1;;;77050:64:0;;;;;;;;;;;;;;;77138:13;77128:6;:23;;;;;;;;;77125:908;;;77167:21;77191:8;77200:4;77191:14;;;;;;;;;;;;;;;;;;;;;;;77237:12;;77278:32;;;-1:-1:-1;;;77278:32:0;;77304:4;77278:32;;;;;;77191:14;;-1:-1:-1;;;;;;77237:12:0;;;;77191:14;77237:12;;77278:17;;:32;;;;;77191:14;77278:32;;;;;;77237:12;77278:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77278:32:0;77353:8;;77278:32;;-1:-1:-1;77325:43:0;;-1:-1:-1;;;;;77325:19:0;;;;77353:8;77278:32;77325:19;:43::i;:::-;77403:8;;:35;;-1:-1:-1;;;77403:35:0;;-1:-1:-1;;;;;77403:35:0;;;;;;;;;77383:17;;77403:8;;;;;:16;;77420:7;;77429:8;;77403:35;;;77429:8;77403;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77403:35:0;77468;;;-1:-1:-1;;;77468:35:0;;77497:4;77468:35;;;;;;77403;;-1:-1:-1;;;;;;77468:20:0;;;;;:35;;;;;77403;;77468;;;;;;;;:20;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77468:35:0;77461:42;;77453:67;;;;;-1:-1:-1;;;77453:67:0;;;;;;;;;;;;-1:-1:-1;;;77453:67:0;;;;;;;;;;;;;;;77535:25;;-1:-1:-1;;;;;;77535:25:0;-1:-1:-1;;;;;77535:25:0;;;;;;;;-1:-1:-1;77125:908:0;;-1:-1:-1;77125:908:0;;77590:12;77580:6;:22;;;;;;;;;77577:456;;;77618:26;77647:13;77661:4;77647:19;;;;;;;;;;;;;;;;;;;;;;;77698:12;;77739:32;;;-1:-1:-1;;;77739:32:0;;77765:4;77739:32;;;;;;77647:19;;-1:-1:-1;;;;;;77698:12:0;;;;77647:19;77698:12;;77739:17;;:32;;;;;77647:19;77739:32;;;;;;77698:12;77739:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77739:32:0;77814:8;;77739:32;;-1:-1:-1;77786:43:0;;-1:-1:-1;;;;;77786:19:0;;;;77814:8;77739:32;77786:19;:43::i;:::-;77864:8;;:35;;-1:-1:-1;;;77864:35:0;;-1:-1:-1;;;;;77864:35:0;;;;;;;;;77844:17;;77864:8;;;;;:16;;77881:7;;77890:8;;77864:35;;;77890:8;77864;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77864:35:0;77929;;;-1:-1:-1;;;77929:35:0;;77958:4;77929:35;;;;;;77864;;-1:-1:-1;;;;;;77929:20:0;;;;;:35;;;;;77864;;77929;;;;;;;;:20;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77929:35:0;77922:42;;77914:67;;;;;-1:-1:-1;;;77914:67:0;;;;;;;;;;;;-1:-1:-1;;;77914:67:0;;;;;;;;;;;;;;;77996:25;;-1:-1:-1;;;;;;77996:25:0;-1:-1:-1;;;;;77996:25:0;;;;;;;;-1:-1:-1;;77577:456:0;76952:1088;;;:::o;53768:95::-;53840:8;:15;53768:95;:::o;52523:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52523:26:0;;;;-1:-1:-1;52523:26:0;;;;;;;:::o;52766:34::-;;;;:::o;52922:24::-;;;;:::o;76726:103::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;76801:8:::1;:20:::0;;-1:-1:-1;;;;;;76801:20:0::1;-1:-1:-1::0;;;;;76801:20:0;;;::::1;::::0;;;::::1;::::0;;76726:103::o;65334:113::-;65391:7;65418:14;;;:8;:14;;;;;:21;;65334:113::o;69524:1239::-;69581:26;69610:13;69624:4;69610:19;;;;;;;;;;;;;;;;;;69581:48;;69660:4;:20;;;69644:12;:36;69640:75;;69697:7;;;69640:75;69744:12;;:37;;;-1:-1:-1;;;69744:37:0;;69775:4;69744:37;;;;;;69725:16;;-1:-1:-1;;;;;69744:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69744:37:0;;-1:-1:-1;69796:13:0;69792:102;;-1:-1:-1;69849:12:0;69826:20;;;;:35;69876:7;;69792:102;69904:19;69926:65;69942:4;:20;;;69964:12;69978;69926:15;:65::i;:::-;69904:87;;70002:19;70024:58;70061:20;;70024:32;70040:4;:15;;;70024:11;:15;;:32;;;;:::i;:::-;:36;;:58::i;:::-;70002:80;-1:-1:-1;70093:27:0;70123:28;70147:3;70123:19;70002:80;70139:2;70123:15;:19::i;:28::-;70093:58;-1:-1:-1;70162:29:0;70194:36;:11;70093:58;70194:15;:36::i;:::-;70162:68;-1:-1:-1;70270:75:0;70301:43;70335:8;70301:29;:19;70325:4;70301:23;:29::i;:43::-;70270:26;;;;;:30;:75::i;:::-;70241:26;;;:104;70389:24;;;;70356:17;;70376:38;;:8;;:12;:38::i;:::-;70356:58;-1:-1:-1;70428:13:0;;70425:285;;70488:80;70521:46;70557:9;70521:31;:21;70547:4;70521:25;:31::i;:46::-;70488:28;;;;;:32;:80::i;:::-;70457:28;;;;:111;;;;70583:5;;:38;;;-1:-1:-1;;;70583:38:0;;70602:4;70583:38;;;;;;;;;;;;;;-1:-1:-1;;;;;70583:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;:5;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70425:285;;;70652:5;;:46;;;-1:-1:-1;;;70652:46:0;;70671:4;70652:46;;;;;;;;;;;;-1:-1:-1;;;;;70652:5:0;;;;:10;;:46;;;;;:5;;:46;;;;;;;;:5;;:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70425:285;70743:12;70720:4;:20;;:35;;;;69524:1239;;;;;;;;;:::o;52890:25::-;;;;:::o;67050:903::-;67127:7;67147:26;67176:13;67190:4;67176:19;;;;;;;;;;;;;;;;67235;;;:13;:19;;;;;;-1:-1:-1;;;;;67235:26:0;;;;;;;;;;;67176:19;;;;;;;;67304:26;;;;67360:12;;:37;;-1:-1:-1;;;67360:37:0;;67391:4;67360:37;;;;;;67176:19;;-1:-1:-1;67235:26:0;;67304;;67176:19;;67360:12;;;:22;;:37;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67360:37:0;67427:20;;;;67360:37;;-1:-1:-1;67412:12:0;:35;:52;;;;-1:-1:-1;67451:13:0;;;67412:52;67408:451;;;67481:20;67504:65;67520:4;:20;;;67542:12;67556;67504:15;:65::i;:::-;67481:88;;67584:19;67606:59;67644:20;;67606:33;67623:4;:15;;;67606:12;:16;;:33;;;;:::i;:59::-;67584:81;-1:-1:-1;67680:27:0;67710:28;67734:3;67710:19;67584:81;67726:2;67710:15;:19::i;:28::-;67680:58;-1:-1:-1;67777:70:0;67803:43;67837:8;67803:29;67680:58;67827:4;67803:23;:29::i;:43::-;67777:21;;:25;:70::i;:::-;67753:94;;67408:451;;;;67876:69;67929:4;:15;;;67876:48;67919:4;67876:38;67892:21;67876:4;:11;;;:15;;:38;;;;:::i;:48::-;:52;;:69::i;:::-;67869:76;;;;;;67050:903;;;;;:::o;75022:386::-;75086:26;75115:13;75129:4;75115:19;;;;;;;;;;;;;;;;75174;;;:13;:19;;;;;;75194:10;75174:31;;;;;;;;75263:11;;;;75115:19;;;;;;;75216:12;;75115:19;;-1:-1:-1;75216:59:0;;-1:-1:-1;;;;;75216:12:0;;;;;75194:10;75216:25;:59::i;:::-;75332:11;;;;75291:53;;;;;;;75326:4;;75314:10;;75291:53;;;;;;;;;75369:1;75355:11;;;:15;;;75381;;;;:19;-1:-1:-1;;75022:386:0:o;58150:904::-;58217:21;58241:8;58250:4;58241:14;;;;;;;;;;;;;;;;;;;;;58274:9;;;;58241:14;;-1:-1:-1;58274:9:0;;:18;;:82;;-1:-1:-1;58296:9:0;;;;;;:60;;;;;58339:9;;58326:10;;:22;58351:4;58326:29;58309:12;:47;;58296:60;58266:91;;;;;;58368:21;58392:14;;;:8;:14;;;;;;;;58407:10;58392:26;;;;;;;58437:11;;:22;-1:-1:-1;58437:22:0;58429:53;;;;;-1:-1:-1;;;58429:53:0;;;;;;;;;;;;-1:-1:-1;;;58429:53:0;;;;;;;;;;;;;;;58493:16;58504:4;58493:10;:16::i;:::-;58520:15;58538:69;58591:4;:15;;;58538:48;58581:4;58538:38;58554:4;:21;;;58538:4;:11;;;:15;;:38;;;;:::i;:69::-;58520:87;-1:-1:-1;58621:11:0;;58618:140;;58649:38;58667:10;58679:7;58649:17;:38::i;:::-;58719:14;;;;:27;;58738:7;58719:18;:27::i;:::-;58702:14;;;:44;58618:140;58771:11;;58768:151;;58813:11;;:24;;58829:7;58813:15;:24::i;:::-;58799:38;;58852:12;;:55;;-1:-1:-1;;;;;58852:12:0;58886:10;58899:7;58852:25;:55::i;:::-;58963:21;;;;58947:11;;:48;;58990:4;;58947:38;;:15;:38::i;:48::-;58929:15;;;:66;59011:35;;;;;;;;59032:4;;59020:10;;59011:35;;;;;;;;;58150:904;;;;;:::o;52858:25::-;;;;:::o;55929:466::-;56000:13;55990:6;:23;;;;;;;;;55987:401;;;56046:8;:15;56029:14;56076:93;56104:6;56098:3;:12;56076:93;;;56138:15;56149:3;56138:10;:15::i;:::-;56112:5;;56076:93;;;;55987:401;;;;56198:13;56188:6;:23;;;;;;;;;56185:203;;;56244:13;:20;56227:14;56279:98;56307:6;56301:3;:12;56279:98;;;56341:20;56357:3;56341:15;:20::i;:::-;56315:5;;56279:98;;56471:741;56523:21;56547:8;56556:4;56547:14;;;;;;;;;;;;;;;;;;56523:38;;56592:4;:20;;;56576:12;:36;56572:75;;56629:7;;;56572:75;56676:12;;:37;;;-1:-1:-1;;;56676:37:0;;56707:4;56676:37;;;;;;56657:16;;-1:-1:-1;;;;;56676:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56676:37:0;;-1:-1:-1;56728:13:0;56724:102;;-1:-1:-1;56781:12:0;56758:20;;;;:35;56808:7;;56724:102;56836:20;56859:66;56875:4;:20;;;56897:12;56911:13;56859:15;:66::i;:::-;56836:89;;56936:19;56958:54;56996:15;;56958:33;56975:4;:15;;;56958:12;:16;;:33;;;;:::i;:54::-;57023:5;;:38;;;-1:-1:-1;;;57023:38:0;;57042:4;57023:38;;;;;;;;;;;;56936:76;;-1:-1:-1;;;;;;57023:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;;:5;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57096:62;57122:35;57148:8;57122:21;57138:4;57122:11;:15;;:21;;;;:::i;:35::-;57096:21;;;;;:25;:62::i;:::-;57072:21;;;:86;-1:-1:-1;;57192:12:0;57169:20;;;;:35;;;;-1:-1:-1;56471:741:0;:::o;59125:356::-;59184:21;59208:8;59217:4;59208:14;;;;;;;;;;;;;;;;59257;;;:8;:14;;;;;;59272:10;59257:26;;;;;;;;59341:11;;59208:14;;;;;;;59294:12;;59208:14;;-1:-1:-1;59294:59:0;;-1:-1:-1;;;;;59294:12:0;;;;;59272:10;59294:25;:59::i;:::-;59405:11;;59369:48;;;;;;;59399:4;;59387:10;;59369:48;;;;;;;;;59442:1;59428:15;;;59454;;;;:19;-1:-1:-1;;59125:356:0:o;66735:250::-;66833:7;66856:19;;;:13;:19;;;;;;;;-1:-1:-1;;;;;66856:26:0;;;;;;;;;:30;:38;;66853:77;;-1:-1:-1;66917:1:0;66910:8;;66853:77;66947:30;66965:4;66971:5;66947:17;:30::i;:::-;66940:37;;66735:250;;;;;;:::o;75416:124::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;75498:15:::1;:34:::0;;-1:-1:-1;;;;;;75498:34:0::1;-1:-1:-1::0;;;;;75498:34:0;;;::::1;::::0;;;::::1;::::0;;75416:124::o;54694:317::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;54792:11:::1;54788:74;;;54820:30;54836:13;54820:15;:30::i;:::-;54890:63;54941:11;54890:46;54910:8;54919:4;54910:14;;;;;;;;;;;;;;;;;;:25;;;54890:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;54872:15;:81;;;;54992:11;54964:8;54973:4;54964:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;54694:317:::0;;;:::o;52188:23::-;;;-1:-1:-1;;;;;52188:23:0;;:::o;60700:173::-;60750:7;60823:42;60838:12;60852;60823:14;:42::i;:::-;60777:43;60792:12;60806:13;60777:14;:43::i;:::-;:88;60770:95;;60700:173;:::o;52258:28::-;;;;:::o;28910:148::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;29017:1:::1;29001:6:::0;;28980:40:::1;::::0;-1:-1:-1;;;;;29001:6:0;;::::1;::::0;28980:40:::1;::::0;29017:1;;28980:40:::1;29048:1;29031:19:::0;;-1:-1:-1;;;;;;29031:19:0::1;::::0;;28910:148::o;66382:345::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;66489:11:::1;66485:73;;;66517:29;66533:12;66517:15;:29::i;:::-;66591:73;66652:11;66591:56;66616:13;66630:4;66616:19;;;;;;;;;;;;;;;;;;:30;;;66591:20;;:24;;:56;;;;:::i;:73::-;66568:20;:96;;;;66708:11;66675:13;66689:4;66675:19;;;;;;;;;;;;;;;;;;:30;;:44;;;;66382:345:::0;;;:::o;52459:30::-;;;-1:-1:-1;;;;;52459:30:0;;:::o;50702:39::-;50739:2;50702:39;:::o;52391:30::-;;;-1:-1:-1;;;;;52391:30:0;;:::o;28268:79::-;28306:7;28333:6;-1:-1:-1;;;;;28333:6:0;28268:79;:::o;59935:757::-;60011:7;60044:10;;60035:6;:19;60031:59;;;-1:-1:-1;60077:1:0;60070:8;;60031:59;60100:18;60121:22;60132:10;;60121:6;:10;;:22;;;;:::i;:::-;60100:43;;60172:9;;60158:10;:23;60154:63;;60204:1;60197:8;;;;;60154:63;60227:11;60241:26;60256:10;;60241;:14;;:26;;;;:::i;:::-;60227:40;;60278:19;60300:42;60338:3;60332:2;:9;60300:27;60323:3;60318:1;:8;60300:13;;:17;;:27;;;;:::i;:42::-;60278:64;;60370:1;60356:11;:15;:47;;;;;60390:13;;60375:11;:28;;60356:47;60353:313;;;60432:13;60422:6;:23;;;;;;;;;60419:95;;;60472:26;60495:2;60472:18;:11;60488:1;60472:15;:18::i;:26::-;60465:33;;;;;;;60419:95;60541:12;60531:6;:22;;;;;;;;;60528:94;;;60580:26;60603:2;60580:18;:11;60596:1;60580:15;:18::i;60528:94::-;60643:11;-1:-1:-1;60636:18:0;;-1:-1:-1;;60636:18:0;60353:313;-1:-1:-1;60683:1:0;;59935:757;-1:-1:-1;;;;;59935:757:0:o;55076:770::-;55150:7;55170:21;55194:8;55203:4;55194:14;;;;;;;;;;;;;;;;55243;;;:8;:14;;;;;;-1:-1:-1;;;;;55243:21:0;;;;;;;;;;;55194:14;;;;;;;;55302:21;;;;55353:12;;:37;;-1:-1:-1;;;55353:37:0;;55384:4;55353:37;;;;;;55194:14;;-1:-1:-1;55243:21:0;;55302;;55194:14;;55353:12;;;:22;;:37;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55353:37:0;55420:20;;;;55353:37;;-1:-1:-1;55405:12:0;:35;:52;;;;-1:-1:-1;55444:13:0;;;55405:52;55401:356;;;55474:20;55497:66;55513:4;:20;;;55535:12;55549:13;55497:15;:66::i;:::-;55474:89;;55578:19;55600:54;55638:15;;55600:33;55617:4;:15;;;55600:12;:16;;:33;;;;:::i;:54::-;55578:76;-1:-1:-1;55688:57:0;55709:35;55735:8;55709:21;55578:76;55725:4;55709:15;:21::i;:35::-;55688:16;;:20;:57::i;:::-;55669:76;;55401:356;;;55774:64;55822:4;:15;;;55774:43;55812:4;55774:33;55790:16;55774:4;:11;;;:15;;:33;;;;:::i;65221:105::-;65298:13;:20;65221:105;:::o;62547:47::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;62547:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62547:47:0;;;;-1:-1:-1;62547:47:0;;-1:-1:-1;62547:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;52605:66::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;70832:2142::-;70917:21;70941:14;;;:8;:14;;;;;:20;;70956:4;;70941:20;;;;;;;;;;;;;;;;;;;70980:12;;70941:20;;-1:-1:-1;;;;;;70980:12:0;70972:51;;;;;-1:-1:-1;;;70972:51:0;;;;;;;;;;;;-1:-1:-1;;;70972:51:0;;;;;;;;;;;;;;;71034:26;71063:13;71077:4;71063:19;;;;;;;;;;;;;;;;71122;;;:13;:19;;;;;;71142:10;71122:31;;;;;;;71063:19;;;;;;;;-1:-1:-1;71164:21:0;71136:4;71164:15;:21::i;:::-;71200:11;;;;:15;71196:390;;71240:8;;:16;;71232:49;;;;;-1:-1:-1;;;71232:49:0;;;;;;;;;;;;-1:-1:-1;;;71232:49:0;;;;;;;;;;;;;;;71296:20;71319:74;71377:4;:15;;;71319:53;71367:4;71319:43;71335:4;:26;;;71319:4;:11;;;:15;;:43;;;;:::i;:74::-;71296:97;-1:-1:-1;71411:16:0;;71408:167;;71448:43;71466:10;71478:12;71448:17;:43::i;:::-;71527:14;;;;:32;;71546:12;71527:18;:32::i;:::-;71510:14;;;:49;71408:167;71196:390;;50739:2;71599:4;:12;;;:26;71596:449;;71641:22;71666:76;71726:4;:15;;;71666:55;71716:4;71666:45;71682:4;:28;;;71666:4;:11;;;:15;;:45;;;;:::i;:76::-;71641:101;-1:-1:-1;71760:18:0;;71757:277;;71817:12;;71799:47;;-1:-1:-1;;;;;71817:12:0;71831:14;71799:17;:47::i;:::-;71865:33;71901:19;;;:13;:19;;;;;;;;71921:12;;-1:-1:-1;;;;;71921:12:0;71901:33;;;;;;;71977:21;;;;:41;;72003:14;71977:25;:41::i;:::-;71953:21;;;;:65;71757:277;71596:449;;72058:11;;72055:691;;72086:12;;:74;;-1:-1:-1;;;;;72086:12:0;72124:10;72145:4;72152:7;72086:29;:74::i;:::-;72208:11;;;;72205:282;;72244:15;;;72293:12;;;;:19;;72310:1;72293:16;:19::i;:::-;72278:12;;;:34;;;50739:2;72334:26;72331:141;;;72440:11;;;;72411:24;;;;:41;;:28;:41::i;:::-;72384:24;;;:68;72331:141;50739:2;72504:4;:12;;;:25;72501:128;;;72576:24;;;;:37;;72605:7;72576:28;:37::i;:::-;72549:24;;;:64;72501:128;72657:11;;;;:24;;72673:7;72657:15;:24::i;:::-;72643:11;;;:38;72710:11;;;;:24;;72726:7;72710:15;:24::i;:::-;72696:11;;;:38;72055:691;72774:53;72822:4;72774:43;72790:4;:26;;;72774:4;:11;;;:15;;:43;;;;:::i;:53::-;72756:15;;;:71;72872:28;;;;72856:11;;;;:55;;72906:4;;72856:45;;:15;:45::i;:55::-;72838:15;;;:73;72927:39;;;;;;;;72952:4;;72940:10;;72927:39;;;;;;;;;70832:2142;;;;;;:::o;54032:565::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;54145:11:::1;54141:74;;;54173:30;54189:13;54173:15;:30::i;:::-;54225:23;54266:10;;54251:12;:25;:53;;54294:10;;54251:53;;;54279:12;54251:53;54333:15;::::0;54225:79;;-1:-1:-1;54333:32:0::1;::::0;54353:11;54333:19:::1;:32::i;:::-;54315:15;:50:::0;54390:198:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;54390:198:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;54390:198:0;;;;;;;::::1;;::::0;;;;;;54376:8:::1;:213:::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;54376:213:0::1;::::0;;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;-1:-1:-1;54376:213:0;;;;;;;;-1:-1:-1;;54376:213:0::1;::::0;::::1;;::::0;;;::::1;::::0;;54032:565::o;65616:669::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;65726:11:::1;65722:73;;;65754:29;65770:12;65754:15;:29::i;:::-;65805:23;65846:10;;65831:12;:25;:53;;65874:10;;65831:53;;;65859:12;65831:53;65918:20;::::0;65805:79;;-1:-1:-1;65918:37:0::1;::::0;65943:11;65918:24:::1;:37::i;:::-;65895:20;:60:::0;65985:291:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;65985:291:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;65985:291:0;;;;;;;;;;;;;;;;;;;;;;;;65966:13:::1;:311:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;65966:311:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65966:311:0;;;;;;;65616:669::o;52953:24::-;;;;:::o;64188:76::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;64096:36::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64096:36:0;;;;-1:-1:-1;64096:36:0;;;;;;;;;:::o;52984:28::-;;;;:::o;73025:1926::-;73097:26;73126:13;73140:4;73126:19;;;;;;;;;;;;;;;;73185;;;:13;:19;;;;;;73205:10;73185:31;;;;;;;73251:14;;;:8;:14;;;;;73266:8;;73251:24;;73126:19;;;;;;;;-1:-1:-1;73185:31:0;;73126:19;73251:24;;;;;;;;;;;;;;;;73227:48;;73309:7;73294:4;:11;;;:22;;73286:53;;;;;-1:-1:-1;;;73286:53:0;;;;;;;;;;;;-1:-1:-1;;;73286:53:0;;;;;;;;;;;;;;;73350:21;73366:4;73350:15;:21::i;:::-;73382:20;73405:74;73463:4;:15;;;73405:53;73453:4;73405:43;73421:4;:26;;;73405:4;:11;;;:15;;:43;;;;:::i;:74::-;73382:97;-1:-1:-1;73493:16:0;;73490:155;;73526:43;73544:10;73556:12;73526:17;:43::i;:::-;73601:14;;;;:32;;73620:12;73601:18;:32::i;:::-;73584:14;;;:49;73490:155;50739:2;73658:4;:12;;;:26;73655:449;;73700:22;73725:76;73785:4;:15;;;73725:55;73775:4;73725:45;73741:4;:28;;;73725:4;:11;;;:15;;:45;;;;:::i;:76::-;73700:101;-1:-1:-1;73819:18:0;;73816:277;;73876:12;;73858:47;;-1:-1:-1;;;;;73876:12:0;73890:14;73858:17;:47::i;:::-;73924:33;73960:19;;;:13;:19;;;;;;;;73980:12;;-1:-1:-1;;;;;73980:12:0;73960:33;;;;;;;74036:21;;;;:41;;74062:14;74036:25;:41::i;:::-;74012:21;;;;:65;73816:277;73655:449;;74117:11;;74114:608;;74159:11;;;;:24;;74175:7;74159:15;:24::i;:::-;74145:11;;;:38;;;74198:248;;50739:2;74240:4;:12;;;:26;74237:141;;;74346:11;;;;74317:24;;;;:41;;:28;:41::i;:::-;74290:24;;;:68;74237:141;74411:12;;;;:19;;74428:1;74411:16;:19::i;:::-;74396:12;;;:34;74198:248;50739:2;74463:4;:12;;;:25;74460:128;;;74535:24;;;;:37;;74564:7;74535:28;:37::i;:::-;74508:24;;;:64;74460:128;74616:11;;;;:24;;74632:7;74616:15;:24::i;:::-;74602:11;;;:38;74655:12;;:55;;-1:-1:-1;;;;;74655:12:0;74689:10;74702:7;74655:25;:55::i;:::-;74750;74800:4;74750:45;74766:4;:28;;;74750:4;:11;;;:15;;:45;;;;:::i;:55::-;74732:15;;;:73;74850:26;;;;74834:11;;;;:53;;74882:4;;74834:43;;:15;:43::i;:53::-;74816:15;;;:71;74903:40;;;;;;;;74929:4;;74917:10;;74903:40;;;;;;;;;73025:1926;;;;;;:::o;57281:818::-;57347:21;57371:8;57380:4;57371:14;;;;;;;;;;;;;;;;57420;;;:8;:14;;;;;;57435:10;57420:26;;;;;;;57371:14;;;;;;;;-1:-1:-1;57457:16:0;57429:4;57457:10;:16::i;:::-;57488:11;;:15;57484:301;;57520:15;57538:69;57591:4;:15;;;57538:48;57581:4;57538:38;57554:4;:21;;;57538:4;:11;;;:15;;:38;;;;:::i;:69::-;57520:87;-1:-1:-1;57625:11:0;;57622:152;;57657:38;57675:10;57687:7;57657:17;:38::i;:::-;57731:14;;;;:27;;57750:7;57731:18;:27::i;:::-;57714:14;;;:44;57622:152;57484:301;;57798:11;;57795:170;;57826:12;;:74;;-1:-1:-1;;;;;57826:12:0;57864:10;57885:4;57892:7;57826:29;:74::i;:::-;57929:11;;:24;;57945:7;57929:15;:24::i;:::-;57915:38;;57795:170;58009:21;;;;57993:11;;:48;;58036:4;;57993:38;;:15;:38::i;:48::-;57975:15;;;:66;58057:34;;;;;;;;58077:4;;58065:10;;58057:34;;;;;;;;;57281:818;;;;:::o;75583:492::-;75663:26;75692:13;75706:4;75692:19;;;;;;;;;;;;;;;;;;;;;;;75741:12;;:37;;;-1:-1:-1;;;75741:37:0;;75772:4;75741:37;;;;;;75692:19;;-1:-1:-1;;;;;;75741:12:0;;;;:22;;:37;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75741:37:0;75822:24;;;;75741:37;;-1:-1:-1;75789:17:0;;75809:38;;75741:37;;75809:12;:38::i;:::-;75789:58;-1:-1:-1;75861:13:0;;75858:210;;75890:5;;:54;;;-1:-1:-1;;;75890:54:0;;75909:10;75890:54;;;;75929:4;75890:54;;;;;;;;;;;;-1:-1:-1;;;;;75890:5:0;;;;:18;;:54;;;;;;;;;;;;;;;:5;;:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75990:66:0;;-1:-1:-1;76023:32:0;76045:9;76023:17;:7;76035:4;76023:11;:17::i;:32::-;75990:28;;;;;:32;:66::i;:::-;75959:28;;;:97;75858:210;75583:492;;;;;:::o;76083:453::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;76148:26:::1;76177:13;76191:4;76177:19;;;;;;;;;::::0;;;::::1;::::0;;;76215:15:::1;::::0;76177:19:::1;::::0;;::::1;;::::0;-1:-1:-1;;;;;;76215:15:0::1;:29:::0;;::::1;::::0;:55:::1;;;76269:1;76248:4;:18;;;:22;76215:55;76207:64;;;::::0;::::1;;76306:65;::::0;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;;;;;;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;76306:65:0::1;-1:-1:-1::0;;;76306:65:0::1;::::0;;76401:15:::1;::::0;76429:18:::1;::::0;::::1;::::0;76401:57;;;;76306:65;;-1:-1:-1;;;;;;;76401:15:0;;::::1;::::0;76429:18;;76306:65;;76401:57;;;;;76306:65;76401:57:::1;;;;;;::::0;;;;-1:-1:-1;;76401:57:0;;;;::::1;::::0;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76382:76;;;76472:7;76469:60;;;76516:1;76495:18;::::0;::::1;:22:::0;76469:60:::1;28550:1;;;76083:453:::0;:::o;64271:39::-;;;;:::o;29213:244::-;28490:12;:10;:12::i;:::-;28480:6;;-1:-1:-1;;;;;28480:6:0;;;:22;;;28472:67;;;;;-1:-1:-1;;;28472:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28472:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;29302:22:0;::::1;29294:73;;;;-1:-1:-1::0;;;29294:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29404:6;::::0;;29383:38:::1;::::0;-1:-1:-1;;;;;29383:38:0;;::::1;::::0;29404:6;::::1;::::0;29383:38:::1;::::0;::::1;29432:6;:17:::0;;-1:-1:-1;;;;;;29432:17:0::1;-1:-1:-1::0;;;;;29432:17:0;;;::::1;::::0;;;::::1;::::0;;29213:244::o;64319:894::-;64422:13;;64409:9;:26;64401:35;;;;;;64447:14;;;;:8;:14;;;;;;;;64467:200;;;;;;;64500:10;64467:200;;64540:12;64467:200;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64447:221;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;64447:221:0;-1:-1:-1;;;;;64447:221:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64467:200;;64447:221;;;;;;;;;;;;:::i;:::-;;;;64721:26;64750:13;64764:4;64750:19;;;;;;;;;;;;;;;;64783:15;;64750:19;;;;;;-1:-1:-1;;;;;;64783:15:0;:29;64780:426;;64852:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64852:65:0;-1:-1:-1;;;64852:65:0;;;64951:15;;64979:18;;;;-1:-1:-1;;;;;;;64951:15:0;;64979:33;;65002:9;64979:22;:33::i;:::-;65014:8;64951:72;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;64951:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64932:91;;;65041:7;65038:68;;;65089:1;65068:18;;;:22;65038:68;64780:426;;;;;65180:13;;65157:18;;;;:37;;:22;:37::i;:::-;65136:18;;;:58;64319:894;;;:::o;68239:1209::-;68326:7;68375:19;;;:13;:19;;;;;;;;-1:-1:-1;;;;;68375:26:0;;;;;;;;;68436:14;;;:8;:14;;;;;68451:8;;68436:24;;68326:7;;68436:14;68451:8;68436:24;;;;;;;;;;;;;;;;;;;68474:12;;68436:24;;-1:-1:-1;;;;;;68474:21:0;;;:12;;:21;;;:50;;;50739:2;68499:4;:12;;;:25;68474:50;68471:89;;;68547:1;68540:8;;;;;;68471:89;68570:26;68599:13;68613:4;68599:19;;;;;;;;;;;;;;;;68663:28;68599:19;;;;;68663:28;;;;68721:12;;:37;;;-1:-1:-1;;;68721:37:0;;68752:4;68721:37;;;;;;;;68599:19;;-1:-1:-1;68663:28:0;;68599:19;-1:-1:-1;;;;;68721:12:0;;;;:22;;:37;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68721:37:0;68788:20;;;;68721:37;;-1:-1:-1;68773:12:0;:35;:52;;;;-1:-1:-1;68812:13:0;;;68773:52;68769:583;;;68842:20;68865:65;68881:4;:20;;;68903:12;68917;68865:15;:65::i;:::-;68842:88;;68945:19;68967:59;69005:20;;68967:33;68984:4;:15;;;68967:12;:16;;:33;;;;:::i;:59::-;68945:81;-1:-1:-1;69041:29:0;69073:27;69096:3;69073:18;68945:81;69089:1;69073:15;:18::i;:27::-;69041:59;;69115:17;69135:38;69148:4;:24;;;69135:8;:12;;:38;;;;:::i;:::-;69115:58;-1:-1:-1;69191:13:0;;69188:153;;69250:75;69278:46;69314:9;69278:31;:21;69304:4;69278:25;:31::i;:46::-;69250:23;;:27;:75::i;:::-;69224:101;;69188:153;68769:583;;;;;69369:71;69424:4;:15;;;69369:50;69414:4;69369:40;69385:23;69369:4;:11;;;:15;;:40;;;;:::i;:71::-;69362:78;68239:1209;-1:-1:-1;;;;;;;;68239:1209:0:o;67961:270::-;68069:7;68092:19;;;:13;:19;;;;;;;;-1:-1:-1;;;;;68092:26:0;;;;;;;;;:30;:38;;68089:77;;-1:-1:-1;68153:1:0;68146:8;;68089:77;68183:40;68211:4;68217:5;68183:27;:40::i;60881:951::-;61014:9;;60991:5;;:19;;;-1:-1:-1;;;60991:19:0;;;;60968:7;;61014:9;-1:-1:-1;;;;;60991:5:0;;:17;;:19;;;;;;;;;;;;;;:5;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60991:19:0;:32;60988:71;;-1:-1:-1;61046:1:0;61039:8;;60988:71;61079:10;;61072:4;:17;61069:65;;;61112:10;;61105:17;;61069:65;61167:9;;61152:10;;:25;;:14;:25::i;:::-;61147:2;:30;61144:98;;;61198:32;61228:1;61198:25;61213:9;;61198:10;;:14;;:25;;;;:::i;:32::-;61193:37;;61144:98;61263:2;61255:4;:10;61252:49;;-1:-1:-1;61288:1:0;61281:8;;61252:49;61311:20;61334:28;61349:4;61355:6;61334:14;:28::i;:::-;61311:51;;61373:20;61396:26;61411:2;61415:6;61396:14;:26::i;:::-;61373:49;-1:-1:-1;61433:16:0;61452:12;:2;61459:4;61452:6;:12::i;:::-;61433:31;;61494:12;61478;:28;61475:306;;61522:15;61540:18;61547:10;;61540:2;:6;;:18;;;;:::i;:::-;61522:36;;61587:7;61576:8;:18;61573:65;;;61621:1;61614:8;;;;;;;;61573:65;61652:15;61670:21;:8;61683:7;61670:12;:21::i;:::-;61652:39;-1:-1:-1;61713:56:0;61743:25;:7;61755:12;61743:11;:25::i;:::-;61713;:7;61725:12;61713:11;:25::i;:56::-;61706:63;;;;;;;;;61475:306;61798:26;:8;61811:12;61798;:26::i;:::-;61791:33;60881:951;-1:-1:-1;;;;;;;60881:951:0:o;15727:622::-;16097:10;;;16096:62;;-1:-1:-1;16113:39:0;;;-1:-1:-1;;;16113:39:0;;16137:4;16113:39;;;;-1:-1:-1;;;;;16113:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16113:39:0;:44;16096:62;16088:152;;;;-1:-1:-1;;;16088:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16278:62;;;-1:-1:-1;;;;;16278:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16278:62:0;-1:-1:-1;;;16278:62:0;;;16251:90;;16271:5;;16251:19;:90::i;26824:106::-;26912:10;26824:106;:::o;5074:471::-;5132:7;5377:6;5373:47;;-1:-1:-1;5407:1:0;5400:8;;5373:47;5444:5;;;5448:1;5444;:5;:1;5468:5;;;;;:10;5460:56;;;;-1:-1:-1;;;5460:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6021:132;6079:7;6106:39;6110:1;6113;6106:39;;;;;;;;;;;;;;;;;:3;:39::i;4184:136::-;4242:7;4269:43;4273:1;4276;4269:43;;;;;;;;;;;;;;;;;:3;:43::i;3720:181::-;3778:7;3810:5;;;3834:6;;;;3826:46;;;;;-1:-1:-1;;;3826:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;15068:177;15178:58;;;-1:-1:-1;;;;;15178:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15178:58:0;-1:-1:-1;;;15178:58:0;;;15151:86;;15171:5;;15151:19;:86::i;59597:285::-;59693:5;;:30;;;-1:-1:-1;;;59693:30:0;;59717:4;59693:30;;;;;;59674:16;;-1:-1:-1;;;;;59693:5:0;;:15;;:30;;;;;;;;;;;;;;:5;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59693:30:0;;-1:-1:-1;59738:18:0;;;59734:141;;;59773:5;;:29;;;-1:-1:-1;;;59773:29:0;;-1:-1:-1;;;;;59773:29:0;;;;;;;;;;;;;;;:5;;;;;:14;;:29;;;;;;;;;;;;;;:5;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59734:141:0;;-1:-1:-1;59734:141:0;;59835:5;;:28;;;-1:-1:-1;;;59835:28:0;;-1:-1:-1;;;;;59835:28:0;;;;;;;;;;;;;;;:5;;;;;:14;;:28;;;;;;;;;;;;;;:5;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15253:205;15381:68;;;-1:-1:-1;;;;;15381:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15381:68:0;-1:-1:-1;;;15381:68:0;;;15354:96;;15374:5;;15354:19;:96::i;7392:130::-;7450:7;7477:37;7481:1;7484;7477:37;;;;;;;;;;;;;;;;;:3;:37::i;17373:761::-;17797:23;17823:69;17851:4;17823:69;;;;;;;;;;;;;;;;;17831:5;-1:-1:-1;;;;;17823:27:0;;;:69;;;;;:::i;:::-;17907:17;;17797:95;;-1:-1:-1;17907:21:0;17903:224;;18049:10;18038:30;;;;;;;;;;;;;;;-1:-1:-1;18038:30:0;18030:85;;;;-1:-1:-1;;;18030:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6649:278;6735:7;6770:12;6763:5;6755:28;;;;-1:-1:-1;;;6755:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6794:9;6810:1;6806;:5;;;;;;;6649:278;-1:-1:-1;;;;;6649:278:0:o;4623:192::-;4709:7;4745:12;4737:6;;;;4729:29;;;;-1:-1:-1;;;4729:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4781:5:0;;;4623:192::o;8007:166::-;8093:7;8129:12;8121:6;8113:29;;;;-1:-1:-1;;;8113:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8164:1;8160;:5;;;;;;;8007:166;-1:-1:-1;;;;8007:166:0:o;12057:196::-;12160:12;12192:53;12215:6;12223:4;12229:1;12232:12;13564;13597:18;13608:6;13597:10;:18::i;:::-;13589:60;;;;;-1:-1:-1;;;13589:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13723:12;13737:23;13764:6;-1:-1:-1;;;;;13764:11:0;13784:8;13795:4;13764:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;13764:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13722:78;;;;13815:7;13811:595;;;13846:10;-1:-1:-1;13839:17:0;;-1:-1:-1;13839:17:0;13811:595;13960:17;;:21;13956:439;;14223:10;14217:17;14284:15;14271:10;14267:2;14263:19;14256:44;14171:148;14359:20;;-1:-1:-1;;;14359:20:0;;;;;;;;;;;;;;;;;14366:12;;14359:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13434:979;;;;;;;:::o;8942:619::-;9002:4;9470:20;;9313:66;9510:23;;;;;;:42;;-1:-1:-1;;9537:15:0;;;9502:51;-1:-1:-1;;8942:619:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;
Swarm Source
ipfs://c16ec89a0c57aba9d962bcefda941e154fb332cdbd8cd74b8d5b1ce1e61463d9
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.